diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 5d26a30c3b7dd..07e64d700a61b 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -5192,6 +5192,7 @@ module ts {
                     case SyntaxKind.CallExpression:
                     case SyntaxKind.NewExpression:
                     case SyntaxKind.TypeAssertionExpression:
+                    case SyntaxKind.AsExpression:
                     case SyntaxKind.ParenthesizedExpression:
                     case SyntaxKind.PrefixUnaryExpression:
                     case SyntaxKind.DeleteExpression:
@@ -5958,7 +5959,8 @@ module ts {
                 case SyntaxKind.NewExpression:
                     return getContextualTypeForArgument(<CallExpression>parent, node);
                 case SyntaxKind.TypeAssertionExpression:
-                    return getTypeFromTypeNode((<TypeAssertion>parent).type);
+                case SyntaxKind.AsExpression:
+                    return getTypeFromTypeNode((<AssertionExpression>parent).type);
                 case SyntaxKind.BinaryExpression:
                     return getContextualTypeForBinaryOperand(node);
                 case SyntaxKind.PropertyAssignment:
@@ -7261,7 +7263,7 @@ module ts {
             return getReturnTypeOfSignature(getResolvedSignature(node));
         }
 
-        function checkTypeAssertion(node: TypeAssertion): Type {
+        function checkAssertion(node: AssertionExpression) {
             let exprType = checkExpression(node.expression);
             let targetType = getTypeFromTypeNode(node.type);
             if (produceDiagnostics && targetType !== unknownType) {
@@ -8134,8 +8136,6 @@ module ts {
                     return checkCallExpression(<CallExpression>node);
                 case SyntaxKind.TaggedTemplateExpression:
                     return checkTaggedTemplateExpression(<TaggedTemplateExpression>node);
-                case SyntaxKind.TypeAssertionExpression:
-                    return checkTypeAssertion(<TypeAssertion>node);
                 case SyntaxKind.ParenthesizedExpression:
                     return checkExpression((<ParenthesizedExpression>node).expression, contextualMapper);
                 case SyntaxKind.ClassExpression:
@@ -8145,6 +8145,9 @@ module ts {
                     return checkFunctionExpressionOrObjectLiteralMethod(<FunctionExpression>node, contextualMapper);
                 case SyntaxKind.TypeOfExpression:
                     return checkTypeOfExpression(<TypeOfExpression>node);
+                case SyntaxKind.TypeAssertionExpression:
+                case SyntaxKind.AsExpression:
+                    return checkAssertion(<AssertionExpression>node);
                 case SyntaxKind.DeleteExpression:
                     return checkDeleteExpression(<DeleteExpression>node);
                 case SyntaxKind.VoidExpression:
@@ -10945,6 +10948,7 @@ module ts {
                 case SyntaxKind.TemplateExpression:
                 case SyntaxKind.TemplateSpan:
                 case SyntaxKind.TypeAssertionExpression:
+                case SyntaxKind.AsExpression:
                 case SyntaxKind.ParenthesizedExpression:
                 case SyntaxKind.TypeOfExpression:
                 case SyntaxKind.VoidExpression:
@@ -11286,7 +11290,8 @@ module ts {
                         case SyntaxKind.IndexSignature:
                             return node === (<SignatureDeclaration>parent).type;
                         case SyntaxKind.TypeAssertionExpression:
-                            return node === (<TypeAssertion>parent).type;
+                        case SyntaxKind.AsExpression:
+                            return node === (<AssertionExpression>parent).type;
                         case SyntaxKind.CallExpression:
                         case SyntaxKind.NewExpression:
                             return (<CallExpression>parent).typeArguments && indexOf((<CallExpression>parent).typeArguments, node) >= 0;
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index c9d23ec5ceebf..42e8ec7a45e91 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -1790,8 +1790,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
             }
 
             function skipParentheses(node: Expression): Expression {
-                while (node.kind === SyntaxKind.ParenthesizedExpression || node.kind === SyntaxKind.TypeAssertionExpression) {
-                    node = (<ParenthesizedExpression | TypeAssertion>node).expression;
+                while (node.kind === SyntaxKind.ParenthesizedExpression || node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression) {
+                    node = (<ParenthesizedExpression | AssertionExpression>node).expression;
                 }
                 return node;
             }
@@ -1907,13 +1907,13 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 
             function emitParenExpression(node: ParenthesizedExpression) {
                 if (!node.parent || node.parent.kind !== SyntaxKind.ArrowFunction) {
-                    if (node.expression.kind === SyntaxKind.TypeAssertionExpression) {
-                        let operand = (<TypeAssertion>node.expression).expression;
+                    if (node.expression.kind === SyntaxKind.TypeAssertionExpression || node.expression.kind === SyntaxKind.AsExpression) {
+                        let operand = (<AssertionExpression>node.expression).expression;
 
                         // Make sure we consider all nested cast expressions, e.g.:
                         // (<any><number><any>-A).x;
-                        while (operand.kind == SyntaxKind.TypeAssertionExpression) {
-                            operand = (<TypeAssertion>operand).expression;
+                        while (operand.kind === SyntaxKind.TypeAssertionExpression || operand.kind === SyntaxKind.AsExpression) {
+                            operand = (<AssertionExpression>operand).expression;
                         }
 
                         // We have an expression of the form: (<Type>SubExpr)
@@ -5840,6 +5840,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                         return emitTaggedTemplateExpression(<TaggedTemplateExpression>node);
                     case SyntaxKind.TypeAssertionExpression:
                         return emit((<TypeAssertion>node).expression);
+                    case SyntaxKind.AsExpression:
+                        return emit((<AsExpression>node).expression);
                     case SyntaxKind.ParenthesizedExpression:
                         return emitParenExpression(<ParenthesizedExpression>node);
                     case SyntaxKind.FunctionDeclaration:
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index af9b486a1da4f..a53f3fcd8157f 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -159,6 +159,9 @@ module ts {
                 return visitNode(cbNode, (<BinaryExpression>node).left) ||
                     visitNode(cbNode, (<BinaryExpression>node).operatorToken) ||
                     visitNode(cbNode, (<BinaryExpression>node).right);
+            case SyntaxKind.AsExpression:
+                return visitNode(cbNode, (<AsExpression>node).expression) ||
+                    visitNode(cbNode, (<AsExpression>node).type);
             case SyntaxKind.ConditionalExpression:
                 return visitNode(cbNode, (<ConditionalExpression>node).condition) ||
                     visitNode(cbNode, (<ConditionalExpression>node).questionToken) ||
@@ -2818,7 +2821,23 @@ module ts {
                     break;
                 }
 
-                leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence));
+                if (token === SyntaxKind.AsKeyword) {
+                    // Make sure we *do* perform ASI for constructs like this:
+                    //    var x = foo
+                    //    as (Bar)
+                    // This should be parsed as an initialized variable, followed
+                    // by a function call to 'as' with the argument 'Bar'
+                    if (canParseSemicolon()) {
+                        break;
+                    }
+                    else {
+                        nextToken();
+                        leftOperand = makeAsExpression(leftOperand, parseType());
+                    }
+                }
+                else {
+                    leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence));
+                }
             }
 
             return leftOperand;
@@ -2855,6 +2874,7 @@ module ts {
                 case SyntaxKind.GreaterThanEqualsToken:
                 case SyntaxKind.InstanceOfKeyword:
                 case SyntaxKind.InKeyword:
+                case SyntaxKind.AsKeyword:
                     return 7;
                 case SyntaxKind.LessThanLessThanToken:
                 case SyntaxKind.GreaterThanGreaterThanToken:
@@ -2882,6 +2902,13 @@ module ts {
             return finishNode(node);
         }
 
+        function makeAsExpression(left: Expression, right: TypeNode): AsExpression {
+            let node = <AsExpression>createNode(SyntaxKind.AsExpression, left.pos);
+            node.expression = left;
+            node.type = right;
+            return finishNode(node);
+        }
+
         function parsePrefixUnaryExpression() {
             let node = <PrefixUnaryExpression>createNode(SyntaxKind.PrefixUnaryExpression);
             node.operator = token;
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 86e680ca8b047..66a25a849e4e9 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -207,6 +207,7 @@ module ts {
         ClassExpression,
         OmittedExpression,
         ExpressionWithTypeArguments,
+        AsExpression,
         // Misc
         TemplateSpan,
         SemicolonClassElement,
@@ -404,6 +405,8 @@ module ts {
 
     export type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName | BindingPattern;
 
+    export type AssertionExpression = TypeAssertion | AsExpression;
+
     export interface Declaration extends Node {
         _declarationBrand: any;
         name?: DeclarationName;
@@ -669,6 +672,11 @@ module ts {
         right: Expression;
     }
 
+    export interface AsExpression extends Expression {
+        expression: Expression;
+        type: TypeNode;
+    }
+
     export interface ConditionalExpression extends Expression {
         condition: Expression;
         questionToken: Node;
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 356337e1315cb..14f5173da58d4 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -717,6 +717,7 @@ module ts {
             case SyntaxKind.CallExpression:
             case SyntaxKind.NewExpression:
             case SyntaxKind.TaggedTemplateExpression:
+            case SyntaxKind.AsExpression:
             case SyntaxKind.TypeAssertionExpression:
             case SyntaxKind.ParenthesizedExpression:
             case SyntaxKind.FunctionExpression:
@@ -779,7 +780,8 @@ module ts {
                         return (forInStatement.initializer === node && forInStatement.initializer.kind !== SyntaxKind.VariableDeclarationList) ||
                             forInStatement.expression === node;
                     case SyntaxKind.TypeAssertionExpression:
-                        return node === (<TypeAssertion>parent).expression;
+                    case SyntaxKind.AsExpression:
+                        return node === (<AssertionExpression>parent).expression;
                     case SyntaxKind.TemplateSpan:
                         return node === (<TemplateSpan>parent).expression;
                     case SyntaxKind.ComputedPropertyName:
diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts
index 0b6a6ad0bdce2..cf4a08af758c8 100644
--- a/src/services/formatting/rules.ts
+++ b/src/services/formatting/rules.ts
@@ -457,6 +457,7 @@ module ts.formatting {
             switch (context.contextNode.kind) {
                 case SyntaxKind.BinaryExpression:
                 case SyntaxKind.ConditionalExpression:
+                case SyntaxKind.AsExpression:
                     return true;
                 
                 // equals in binding elements: function foo([[x, y] = [1, 2]])
diff --git a/src/services/formatting/tokenRange.ts b/src/services/formatting/tokenRange.ts
index 712d6f3792e0d..1936ab3630358 100644
--- a/src/services/formatting/tokenRange.ts
+++ b/src/services/formatting/tokenRange.ts
@@ -112,7 +112,7 @@ module ts.formatting {
             static AnyIncludingMultilineComments = TokenRange.FromTokens(TokenRange.Any.GetTokens().concat([SyntaxKind.MultiLineCommentTrivia]));
             static Keywords = TokenRange.FromRange(SyntaxKind.FirstKeyword, SyntaxKind.LastKeyword);
             static BinaryOperators = TokenRange.FromRange(SyntaxKind.FirstBinaryOperator, SyntaxKind.LastBinaryOperator);
-            static BinaryKeywordOperators = TokenRange.FromTokens([SyntaxKind.InKeyword, SyntaxKind.InstanceOfKeyword, SyntaxKind.OfKeyword]);
+            static BinaryKeywordOperators = TokenRange.FromTokens([SyntaxKind.InKeyword, SyntaxKind.InstanceOfKeyword, SyntaxKind.OfKeyword, SyntaxKind.AsKeyword]);
             static UnaryPrefixOperators = TokenRange.FromTokens([SyntaxKind.PlusPlusToken, SyntaxKind.MinusMinusToken, SyntaxKind.TildeToken, SyntaxKind.ExclamationToken]);
             static UnaryPrefixExpressions = TokenRange.FromTokens([SyntaxKind.NumericLiteral, SyntaxKind.Identifier, SyntaxKind.OpenParenToken, SyntaxKind.OpenBracketToken, SyntaxKind.OpenBraceToken, SyntaxKind.ThisKeyword, SyntaxKind.NewKeyword]);
             static UnaryPreincrementExpressions = TokenRange.FromTokens([SyntaxKind.Identifier, SyntaxKind.OpenParenToken, SyntaxKind.ThisKeyword, SyntaxKind.NewKeyword]);
diff --git a/tests/baselines/reference/APISample_linter.js b/tests/baselines/reference/APISample_linter.js
index cd2df23ffbf4f..9582fbaa528e8 100644
--- a/tests/baselines/reference/APISample_linter.js
+++ b/tests/baselines/reference/APISample_linter.js
@@ -75,22 +75,22 @@ function delint(sourceFile) {
     delintNode(sourceFile);
     function delintNode(node) {
         switch (node.kind) {
-            case 187 /* ForStatement */:
-            case 188 /* ForInStatement */:
-            case 186 /* WhileStatement */:
-            case 185 /* DoStatement */:
-                if (node.statement.kind !== 180 /* Block */) {
+            case 188 /* ForStatement */:
+            case 189 /* ForInStatement */:
+            case 187 /* WhileStatement */:
+            case 186 /* DoStatement */:
+                if (node.statement.kind !== 181 /* Block */) {
                     report(node, "A looping statement's contents should be wrapped in a block body.");
                 }
                 break;
-            case 184 /* IfStatement */:
+            case 185 /* IfStatement */:
                 var ifStatement = node;
-                if (ifStatement.thenStatement.kind !== 180 /* Block */) {
+                if (ifStatement.thenStatement.kind !== 181 /* Block */) {
                     report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.");
                 }
                 if (ifStatement.elseStatement &&
-                    ifStatement.elseStatement.kind !== 180 /* Block */ &&
-                    ifStatement.elseStatement.kind !== 184 /* IfStatement */) {
+                    ifStatement.elseStatement.kind !== 181 /* Block */ &&
+                    ifStatement.elseStatement.kind !== 185 /* IfStatement */) {
                     report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.");
                 }
                 break;
diff --git a/tests/baselines/reference/asOperator1.js b/tests/baselines/reference/asOperator1.js
new file mode 100644
index 0000000000000..a00d31d31ef97
--- /dev/null
+++ b/tests/baselines/reference/asOperator1.js
@@ -0,0 +1,12 @@
+//// [asOperator1.ts]
+var as = 43;
+var x = undefined as number;
+var y = (null as string).length;
+var z = Date as any as string;
+
+
+//// [asOperator1.js]
+var as = 43;
+var x = undefined;
+var y = null.length;
+var z = Date;
diff --git a/tests/baselines/reference/asOperator1.symbols b/tests/baselines/reference/asOperator1.symbols
new file mode 100644
index 0000000000000..b6455af5919b0
--- /dev/null
+++ b/tests/baselines/reference/asOperator1.symbols
@@ -0,0 +1,17 @@
+=== tests/cases/conformance/expressions/asOperator/asOperator1.ts ===
+var as = 43;
+>as : Symbol(as, Decl(asOperator1.ts, 0, 3))
+
+var x = undefined as number;
+>x : Symbol(x, Decl(asOperator1.ts, 1, 3))
+>undefined : Symbol(undefined)
+
+var y = (null as string).length;
+>y : Symbol(y, Decl(asOperator1.ts, 2, 3))
+>(null as string).length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+
+var z = Date as any as string;
+>z : Symbol(z, Decl(asOperator1.ts, 3, 3))
+>Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+
diff --git a/tests/baselines/reference/asOperator1.types b/tests/baselines/reference/asOperator1.types
new file mode 100644
index 0000000000000..dae17c581c419
--- /dev/null
+++ b/tests/baselines/reference/asOperator1.types
@@ -0,0 +1,24 @@
+=== tests/cases/conformance/expressions/asOperator/asOperator1.ts ===
+var as = 43;
+>as : number
+>43 : number
+
+var x = undefined as number;
+>x : number
+>undefined as number : number
+>undefined : undefined
+
+var y = (null as string).length;
+>y : number
+>(null as string).length : number
+>(null as string) : string
+>null as string : string
+>null : null
+>length : number
+
+var z = Date as any as string;
+>z : string
+>Date as any as string : string
+>Date as any : any
+>Date : DateConstructor
+
diff --git a/tests/baselines/reference/asOperator2.errors.txt b/tests/baselines/reference/asOperator2.errors.txt
new file mode 100644
index 0000000000000..3b074038c26b0
--- /dev/null
+++ b/tests/baselines/reference/asOperator2.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/expressions/asOperator/asOperator2.ts(1,9): error TS2352: Neither type 'number' nor type 'string' is assignable to the other.
+
+
+==== tests/cases/conformance/expressions/asOperator/asOperator2.ts (1 errors) ====
+    var x = 23 as string;
+            ~~~~~~~~~~~~
+!!! error TS2352: Neither type 'number' nor type 'string' is assignable to the other.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/asOperator2.js b/tests/baselines/reference/asOperator2.js
new file mode 100644
index 0000000000000..32962555d5107
--- /dev/null
+++ b/tests/baselines/reference/asOperator2.js
@@ -0,0 +1,6 @@
+//// [asOperator2.ts]
+var x = 23 as string;
+
+
+//// [asOperator2.js]
+var x = 23;
diff --git a/tests/baselines/reference/asOperator3.js b/tests/baselines/reference/asOperator3.js
new file mode 100644
index 0000000000000..406eae1c9d68b
--- /dev/null
+++ b/tests/baselines/reference/asOperator3.js
@@ -0,0 +1,22 @@
+//// [asOperator3.ts]
+declare function tag(...x: any[]): any;
+
+var a = `${123 + 456 as number}`;
+var b = `leading ${123 + 456 as number}`;
+var c = `${123 + 456 as number} trailing`;
+var d = `Hello ${123} World` as string;
+var e = `Hello` as string;
+var f = 1 + `${1} end of string` as string;
+var g = tag `Hello ${123} World` as string;
+var h = tag `Hello` as string;
+
+//// [asOperator3.js]
+var a = "" + 123 + 456;
+var b = "leading " + 123 + 456;
+var c = 123 + 456 + " trailing";
+var d = ("Hello " + 123 + " World");
+var e = "Hello";
+var f = 1 + (1 + " end of string");
+var g = (_a = ["Hello ", " World"], _a.raw = ["Hello ", " World"], tag(_a, 123));
+var h = (_b = ["Hello"], _b.raw = ["Hello"], tag(_b));
+var _a, _b;
diff --git a/tests/baselines/reference/asOperator3.symbols b/tests/baselines/reference/asOperator3.symbols
new file mode 100644
index 0000000000000..d29a64d3c3a51
--- /dev/null
+++ b/tests/baselines/reference/asOperator3.symbols
@@ -0,0 +1,31 @@
+=== tests/cases/conformance/expressions/asOperator/asOperator3.ts ===
+declare function tag(...x: any[]): any;
+>tag : Symbol(tag, Decl(asOperator3.ts, 0, 0))
+>x : Symbol(x, Decl(asOperator3.ts, 0, 21))
+
+var a = `${123 + 456 as number}`;
+>a : Symbol(a, Decl(asOperator3.ts, 2, 3))
+
+var b = `leading ${123 + 456 as number}`;
+>b : Symbol(b, Decl(asOperator3.ts, 3, 3))
+
+var c = `${123 + 456 as number} trailing`;
+>c : Symbol(c, Decl(asOperator3.ts, 4, 3))
+
+var d = `Hello ${123} World` as string;
+>d : Symbol(d, Decl(asOperator3.ts, 5, 3))
+
+var e = `Hello` as string;
+>e : Symbol(e, Decl(asOperator3.ts, 6, 3))
+
+var f = 1 + `${1} end of string` as string;
+>f : Symbol(f, Decl(asOperator3.ts, 7, 3))
+
+var g = tag `Hello ${123} World` as string;
+>g : Symbol(g, Decl(asOperator3.ts, 8, 3))
+>tag : Symbol(tag, Decl(asOperator3.ts, 0, 0))
+
+var h = tag `Hello` as string;
+>h : Symbol(h, Decl(asOperator3.ts, 9, 3))
+>tag : Symbol(tag, Decl(asOperator3.ts, 0, 0))
+
diff --git a/tests/baselines/reference/asOperator3.types b/tests/baselines/reference/asOperator3.types
new file mode 100644
index 0000000000000..507dfd8b5726f
--- /dev/null
+++ b/tests/baselines/reference/asOperator3.types
@@ -0,0 +1,63 @@
+=== tests/cases/conformance/expressions/asOperator/asOperator3.ts ===
+declare function tag(...x: any[]): any;
+>tag : (...x: any[]) => any
+>x : any[]
+
+var a = `${123 + 456 as number}`;
+>a : string
+>`${123 + 456 as number}` : string
+>123 + 456 as number : number
+>123 + 456 : number
+>123 : number
+>456 : number
+
+var b = `leading ${123 + 456 as number}`;
+>b : string
+>`leading ${123 + 456 as number}` : string
+>123 + 456 as number : number
+>123 + 456 : number
+>123 : number
+>456 : number
+
+var c = `${123 + 456 as number} trailing`;
+>c : string
+>`${123 + 456 as number} trailing` : string
+>123 + 456 as number : number
+>123 + 456 : number
+>123 : number
+>456 : number
+
+var d = `Hello ${123} World` as string;
+>d : string
+>`Hello ${123} World` as string : string
+>`Hello ${123} World` : string
+>123 : number
+
+var e = `Hello` as string;
+>e : string
+>`Hello` as string : string
+>`Hello` : string
+
+var f = 1 + `${1} end of string` as string;
+>f : string
+>1 + `${1} end of string` as string : string
+>1 + `${1} end of string` : string
+>1 : number
+>`${1} end of string` : string
+>1 : number
+
+var g = tag `Hello ${123} World` as string;
+>g : string
+>tag `Hello ${123} World` as string : string
+>tag `Hello ${123} World` : any
+>tag : (...x: any[]) => any
+>`Hello ${123} World` : string
+>123 : number
+
+var h = tag `Hello` as string;
+>h : string
+>tag `Hello` as string : string
+>tag `Hello` : any
+>tag : (...x: any[]) => any
+>`Hello` : string
+
diff --git a/tests/baselines/reference/asOperatorASI.js b/tests/baselines/reference/asOperatorASI.js
new file mode 100644
index 0000000000000..1df39b36e50f5
--- /dev/null
+++ b/tests/baselines/reference/asOperatorASI.js
@@ -0,0 +1,26 @@
+//// [asOperatorASI.ts]
+class Foo { }
+declare function as(...args: any[]);
+
+// Example 1
+var x = 10
+as `Hello world`; // should not error
+
+// Example 2
+var y = 20
+as(Foo); // should emit
+
+
+//// [asOperatorASI.js]
+var Foo = (function () {
+    function Foo() {
+    }
+    return Foo;
+})();
+// Example 1
+var x = 10;
+(_a = ["Hello world"], _a.raw = ["Hello world"], as(_a)); // should not error
+// Example 2
+var y = 20;
+as(Foo); // should emit
+var _a;
diff --git a/tests/baselines/reference/asOperatorASI.symbols b/tests/baselines/reference/asOperatorASI.symbols
new file mode 100644
index 0000000000000..7def6d460c15c
--- /dev/null
+++ b/tests/baselines/reference/asOperatorASI.symbols
@@ -0,0 +1,23 @@
+=== tests/cases/conformance/expressions/asOperator/asOperatorASI.ts ===
+class Foo { }
+>Foo : Symbol(Foo, Decl(asOperatorASI.ts, 0, 0))
+
+declare function as(...args: any[]);
+>as : Symbol(as, Decl(asOperatorASI.ts, 0, 13))
+>args : Symbol(args, Decl(asOperatorASI.ts, 1, 20))
+
+// Example 1
+var x = 10
+>x : Symbol(x, Decl(asOperatorASI.ts, 4, 3))
+
+as `Hello world`; // should not error
+>as : Symbol(as, Decl(asOperatorASI.ts, 0, 13))
+
+// Example 2
+var y = 20
+>y : Symbol(y, Decl(asOperatorASI.ts, 8, 3))
+
+as(Foo); // should emit
+>as : Symbol(as, Decl(asOperatorASI.ts, 0, 13))
+>Foo : Symbol(Foo, Decl(asOperatorASI.ts, 0, 0))
+
diff --git a/tests/baselines/reference/asOperatorASI.types b/tests/baselines/reference/asOperatorASI.types
new file mode 100644
index 0000000000000..61c2d115cf4f6
--- /dev/null
+++ b/tests/baselines/reference/asOperatorASI.types
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/expressions/asOperator/asOperatorASI.ts ===
+class Foo { }
+>Foo : Foo
+
+declare function as(...args: any[]);
+>as : (...args: any[]) => any
+>args : any[]
+
+// Example 1
+var x = 10
+>x : number
+>10 : number
+
+as `Hello world`; // should not error
+>as `Hello world` : any
+>as : (...args: any[]) => any
+>`Hello world` : string
+
+// Example 2
+var y = 20
+>y : number
+>20 : number
+
+as(Foo); // should emit
+>as(Foo) : any
+>as : (...args: any[]) => any
+>Foo : typeof Foo
+
diff --git a/tests/baselines/reference/asOperatorContextualType.errors.txt b/tests/baselines/reference/asOperatorContextualType.errors.txt
new file mode 100644
index 0000000000000..c53b407b5cf02
--- /dev/null
+++ b/tests/baselines/reference/asOperatorContextualType.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts(2,9): error TS2352: Neither type '(v: number) => number' nor type '(x: number) => string' is assignable to the other.
+  Type 'number' is not assignable to type 'string'.
+
+
+==== tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts (1 errors) ====
+    // should error
+    var x = (v => v) as (x: number) => string;
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2352: Neither type '(v: number) => number' nor type '(x: number) => string' is assignable to the other.
+!!! error TS2352:   Type 'number' is not assignable to type 'string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/asOperatorContextualType.js b/tests/baselines/reference/asOperatorContextualType.js
new file mode 100644
index 0000000000000..7b495ada8f403
--- /dev/null
+++ b/tests/baselines/reference/asOperatorContextualType.js
@@ -0,0 +1,7 @@
+//// [asOperatorContextualType.ts]
+// should error
+var x = (v => v) as (x: number) => string;
+
+//// [asOperatorContextualType.js]
+// should error
+var x = (function (v) { return v; });
diff --git a/tests/baselines/reference/asOperatorNames.errors.txt b/tests/baselines/reference/asOperatorNames.errors.txt
new file mode 100644
index 0000000000000..e3dfaab98845b
--- /dev/null
+++ b/tests/baselines/reference/asOperatorNames.errors.txt
@@ -0,0 +1,11 @@
+tests/cases/conformance/expressions/asOperator/asOperatorNames.ts(2,9): error TS2352: Neither type 'number' nor type 'string' is assignable to the other.
+
+
+==== tests/cases/conformance/expressions/asOperator/asOperatorNames.ts (1 errors) ====
+    var a = 20;
+    var b = a as string;
+            ~~~~~~~~~~~
+!!! error TS2352: Neither type 'number' nor type 'string' is assignable to the other.
+    var as = "hello";
+    var as1 = as as string;
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/asOperatorNames.js b/tests/baselines/reference/asOperatorNames.js
new file mode 100644
index 0000000000000..35e80d080e334
--- /dev/null
+++ b/tests/baselines/reference/asOperatorNames.js
@@ -0,0 +1,12 @@
+//// [asOperatorNames.ts]
+var a = 20;
+var b = a as string;
+var as = "hello";
+var as1 = as as string;
+
+
+//// [asOperatorNames.js]
+var a = 20;
+var b = a;
+var as = "hello";
+var as1 = as;
diff --git a/tests/cases/conformance/expressions/asOperator/asOperator1.ts b/tests/cases/conformance/expressions/asOperator/asOperator1.ts
new file mode 100644
index 0000000000000..0c811be27b1b2
--- /dev/null
+++ b/tests/cases/conformance/expressions/asOperator/asOperator1.ts
@@ -0,0 +1,4 @@
+var as = 43;
+var x = undefined as number;
+var y = (null as string).length;
+var z = Date as any as string;
diff --git a/tests/cases/conformance/expressions/asOperator/asOperator2.ts b/tests/cases/conformance/expressions/asOperator/asOperator2.ts
new file mode 100644
index 0000000000000..1fa5f2c938d78
--- /dev/null
+++ b/tests/cases/conformance/expressions/asOperator/asOperator2.ts
@@ -0,0 +1 @@
+var x = 23 as string;
diff --git a/tests/cases/conformance/expressions/asOperator/asOperator3.ts b/tests/cases/conformance/expressions/asOperator/asOperator3.ts
new file mode 100644
index 0000000000000..4c136247e001f
--- /dev/null
+++ b/tests/cases/conformance/expressions/asOperator/asOperator3.ts
@@ -0,0 +1,10 @@
+declare function tag(...x: any[]): any;
+
+var a = `${123 + 456 as number}`;
+var b = `leading ${123 + 456 as number}`;
+var c = `${123 + 456 as number} trailing`;
+var d = `Hello ${123} World` as string;
+var e = `Hello` as string;
+var f = 1 + `${1} end of string` as string;
+var g = tag `Hello ${123} World` as string;
+var h = tag `Hello` as string;
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/asOperator/asOperatorASI.ts b/tests/cases/conformance/expressions/asOperator/asOperatorASI.ts
new file mode 100644
index 0000000000000..a4dd44a15add1
--- /dev/null
+++ b/tests/cases/conformance/expressions/asOperator/asOperatorASI.ts
@@ -0,0 +1,10 @@
+class Foo { }
+declare function as(...args: any[]);
+
+// Example 1
+var x = 10
+as `Hello world`; // should not error
+
+// Example 2
+var y = 20
+as(Foo); // should emit
diff --git a/tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts b/tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts
new file mode 100644
index 0000000000000..d3a23e224ba3d
--- /dev/null
+++ b/tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts
@@ -0,0 +1,2 @@
+// should error
+var x = (v => v) as (x: number) => string;
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/asOperator/asOperatorNames.ts b/tests/cases/conformance/expressions/asOperator/asOperatorNames.ts
new file mode 100644
index 0000000000000..a0b54d43e8451
--- /dev/null
+++ b/tests/cases/conformance/expressions/asOperator/asOperatorNames.ts
@@ -0,0 +1,4 @@
+var a = 20;
+var b = a as string;
+var as = "hello";
+var as1 = as as string;
diff --git a/tests/cases/fourslash/asOperatorFormatting.ts b/tests/cases/fourslash/asOperatorFormatting.ts
new file mode 100644
index 0000000000000..f697ffd8bb6c2
--- /dev/null
+++ b/tests/cases/fourslash/asOperatorFormatting.ts
@@ -0,0 +1,7 @@
+/// <reference path="fourslash.ts" />
+
+//// /**/var x = 3   as  number;
+
+goTo.marker();
+format.document();
+verify.currentLineContentIs("var x = 3 as number;");