From c2e178ee517b75ca3dee308a287100d44b4807b2 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Fri, 17 Apr 2015 12:06:21 -0700
Subject: [PATCH] CR feedback.

---
 src/compiler/checker.ts            |  8 ++++----
 src/compiler/declarationEmitter.ts |  4 ++--
 src/compiler/parser.ts             |  2 +-
 src/compiler/types.ts              | 10 +++++-----
 4 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 4853e9e44af..f946c05ee70 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -3623,7 +3623,7 @@ module ts {
             return links.resolvedType;
         }
 
-        function getStringLiteralType(node: StringLiteralExpression): StringLiteralType {
+        function getStringLiteralType(node: StringLiteral): StringLiteralType {
             if (hasProperty(stringLiteralTypes, node.text)) {
                 return stringLiteralTypes[node.text];
             }
@@ -3633,7 +3633,7 @@ module ts {
             return type;
         }
 
-        function getTypeFromStringLiteral(node: StringLiteralExpression): Type {
+        function getTypeFromStringLiteral(node: StringLiteral): Type {
             let links = getNodeLinks(node);
             if (!links.resolvedType) {
                 links.resolvedType = getStringLiteralType(node);
@@ -3656,7 +3656,7 @@ module ts {
                 case SyntaxKind.VoidKeyword:
                     return voidType;
                 case SyntaxKind.StringLiteral:
-                    return getTypeFromStringLiteral(<StringLiteralExpression>node);
+                    return getTypeFromStringLiteral(<StringLiteral>node);
                 case SyntaxKind.TypeReference:
                     return getTypeFromTypeReference(<TypeReferenceNode>node);
                 case SyntaxKind.HeritageClauseElement:
@@ -6731,7 +6731,7 @@ module ts {
                     let argType = i === 0 && node.kind === SyntaxKind.TaggedTemplateExpression
                         ? globalTemplateStringsArrayType
                         : arg.kind === SyntaxKind.StringLiteral && !reportErrors
-                            ? getStringLiteralType(<StringLiteralExpression>arg)
+                            ? getStringLiteralType(<StringLiteral>arg)
                             : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined);
 
                     // Use argument expression as error location when reporting errors
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 712d2f6b497..3f613271ce1 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -258,7 +258,7 @@ module ts {
             handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning));
         }
 
-        function writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode | StringLiteralExpression, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {
+        function writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {
             writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;
             write(": ");
             if (type) {
@@ -1126,7 +1126,7 @@ module ts {
                 writeLine();
             }
 
-            function getTypeAnnotationFromAccessor(accessor: AccessorDeclaration): TypeNode | StringLiteralExpression {
+            function getTypeAnnotationFromAccessor(accessor: AccessorDeclaration): TypeNode {
                 if (accessor) {
                     return accessor.kind === SyntaxKind.GetAccessor
                         ? accessor.type // Getter - return type
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 5fce6df3bd5..99803f94e4d 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -1803,7 +1803,7 @@ module ts {
         function parseParameterType(): TypeNode {
             if (parseOptional(SyntaxKind.ColonToken)) {
                 return token === SyntaxKind.StringLiteral
-                    ? <StringLiteralTypeNode>parseLiteralNode(/*internName:*/ true)
+                    ? <StringLiteral>parseLiteralNode(/*internName:*/ true)
                     : parseType();
             }
 
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 39904107e97..370ece347a3 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -596,7 +596,11 @@ module ts {
         type: TypeNode;
     }
 
-    export interface StringLiteralTypeNode extends LiteralExpression, TypeNode { }
+    // Note that a StringLiteral AST node is both an Expression and a TypeNode.  The latter is
+    // because string literals can appear in the type annotation of a parameter node.
+    export interface StringLiteral extends LiteralExpression, TypeNode {
+        _stringLiteralBrand: any;
+    }
 
     // Note: 'brands' in our syntax nodes serve to give us a small amount of nominal typing.
     // Consider 'Expression'.  Without the brand, 'Expression' is actually no different
@@ -689,10 +693,6 @@ module ts {
         hasExtendedUnicodeEscape?: boolean;
     }
 
-    export interface StringLiteralExpression extends LiteralExpression, TypeNode {
-        _stringLiteralExpressionBrand: any;
-    }
-
     export interface TemplateExpression extends PrimaryExpression {
         head: LiteralExpression;
         templateSpans: NodeArray<TemplateSpan>;