Merge branch 'master' into templates

Conflicts:
	src/compiler/diagnosticInformationMap.generated.ts
	src/compiler/diagnosticMessages.json
	src/compiler/types.ts
	src/services/utilities.ts

src/services/formatting/smartIndenter.ts

@@ -108,7 +108,7 @@ module ts.formatting {
         function getActualIndentationForListItemBeforeComma(commaToken: Node, sourceFile: SourceFile, options: TypeScript.FormattingOptions): number {
             // previous token is comma that separates items in list - find the previous item and try to derive indentation from it
             var commaItemInfo = findListItemInfo(commaToken);
-            Debug.assert(commaItemInfo.listItemIndex > 0);
+            Debug.assert(commaItemInfo && commaItemInfo.listItemIndex > 0);
             // The item we're interested in is right before the comma
             return deriveActualIndentationFromList(commaItemInfo.list.getChildren(), commaItemInfo.listItemIndex - 1, sourceFile, options);
         }

src/services/services.ts

@@ -711,6 +711,7 @@ module ts {
 
                         case SyntaxKind.ClassDeclaration:
                         case SyntaxKind.InterfaceDeclaration:
+                        case SyntaxKind.TypeAliasDeclaration:
                         case SyntaxKind.EnumDeclaration:
                         case SyntaxKind.ModuleDeclaration:
                         case SyntaxKind.ImportDeclaration:
@@ -1191,6 +1192,9 @@ module ts {
         // interface Y {}
         static interfaceElement = "interface";
 
+        // type T = ...
+        static typeElement = "type";
+
         // enum E
         static enumElement = "enum";
 
@@ -2395,8 +2399,8 @@ module ts {
                 node = currentToken;
                 isRightOfDot = false;
             }
-
-            // Clear the current activeCompletionSession for this session
+
+            // Clear the current activeCompletionSession for this session
             activeCompletionSession = {
                 filename: filename,
                 position: position,
@@ -2443,8 +2447,8 @@ module ts {
             }
             else {
                 var containingObjectLiteral = getContainingObjectLiteralApplicableForCompletion(previousToken);
-                if (containingObjectLiteral) {
-                    // Object literal expression, look up possible property names from contextual type
+                if (containingObjectLiteral) {
+                    // Object literal expression, look up possible property names from contextual type
                     isMemberCompletion = true;
 
                     var contextualType = typeInfoResolver.getContextualType(containingObjectLiteral);
@@ -2747,6 +2751,7 @@ module ts {
 
             if (flags & SymbolFlags.Class) return ScriptElementKind.classElement;
             if (flags & SymbolFlags.Enum) return ScriptElementKind.enumElement;
+            if (flags & SymbolFlags.TypeAlias) return ScriptElementKind.typeElement;
             if (flags & SymbolFlags.Interface) return ScriptElementKind.interfaceElement;
             if (flags & SymbolFlags.TypeParameter) return ScriptElementKind.typeParameterElement;
             
@@ -2818,6 +2823,7 @@ module ts {
                 case SyntaxKind.ModuleDeclaration: return ScriptElementKind.moduleElement;
                 case SyntaxKind.ClassDeclaration: return ScriptElementKind.classElement;
                 case SyntaxKind.InterfaceDeclaration: return ScriptElementKind.interfaceElement;
+                case SyntaxKind.TypeAliasDeclaration: return ScriptElementKind.typeElement;
                 case SyntaxKind.EnumDeclaration: return ScriptElementKind.enumElement;
                 case SyntaxKind.VariableDeclaration: return node.flags & NodeFlags.Const ? ScriptElementKind.constantElement: ScriptElementKind.variableElement;
                 case SyntaxKind.FunctionDeclaration: return ScriptElementKind.functionElement;
@@ -2832,8 +2838,8 @@ module ts {
                 case SyntaxKind.TypeParameter: return ScriptElementKind.typeParameterElement;
                 case SyntaxKind.EnumMember: return ScriptElementKind.variableElement;
                 case SyntaxKind.Parameter: return (node.flags & NodeFlags.AccessibilityModifier) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement;
-                    return ScriptElementKind.unknown;
             }
+            return ScriptElementKind.unknown;
         }
 
         function getSymbolModifiers(symbol: Symbol): string {
@@ -2982,6 +2988,16 @@ module ts {
                 addFullSymbolName(symbol);
                 writeTypeParametersOfSymbol(symbol, sourceFile);
             }
+            if (symbolFlags & SymbolFlags.TypeAlias) {
+                addNewLineIfDisplayPartsExist();
+                displayParts.push(keywordPart(SyntaxKind.TypeKeyword));
+                displayParts.push(spacePart());
+                addFullSymbolName(symbol);
+                displayParts.push(spacePart());
+                displayParts.push(punctuationPart(SyntaxKind.EqualsToken));
+                displayParts.push(spacePart());
+                displayParts.push.apply(displayParts, typeToDisplayParts(typeResolver, typeResolver.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration));
+            }
             if (symbolFlags & SymbolFlags.Enum) {
                 addNewLineIfDisplayPartsExist();
                 displayParts.push(keywordPart(SyntaxKind.EnumKeyword));
@@ -4569,6 +4585,7 @@ module ts {
 
                 case SyntaxKind.TypeParameter:
                 case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.TypeAliasDeclaration:
                 case SyntaxKind.TypeLiteral:
                     return SemanticMeaning.Type;
 
@@ -4615,11 +4632,10 @@ module ts {
             return root.parent.kind === SyntaxKind.TypeReference && !isLastClause;
         }
 
-        function isInRightSideOfImport(node: EntityName) {
+        function isInRightSideOfImport(node: Node) {
             while (node.parent.kind === SyntaxKind.QualifiedName) {
                 node = node.parent;
             }
-
             return node.parent.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>node.parent).entityName === node;
         }
 

src/services/signatureHelp.ts

@@ -226,12 +226,12 @@ module ts.SignatureHelp {
                 };
             }
 
-            if (node.kind === SyntaxKind.GreaterThanToken
-                || node.kind === SyntaxKind.CloseParenToken
-                || node === parent.func) {
-                return undefined;
-            }
-
+            // findListItemInfo can return undefined if we are not in parent's argument list
+            // or type argument list. This includes cases where the cursor is:
+            //   - To the right of the closing paren
+            //   - Between the type arguments and the arguments (greater than token)
+            //   - On the target of the call (parent.func)
+            //   - On the 'new' keyword in a 'new' expression
             return findListItemInfo(node);
         }
 

src/services/utilities.ts

@@ -7,6 +7,15 @@ module ts {
 
     export function findListItemInfo(node: Node): ListItemInfo {
         var syntaxList = findContainingList(node);
+
+        // It is possible at this point for syntaxList to be undefined, either if
+        // node.parent had no list child, or if none of its list children contained
+        // the span of node. If this happens, return undefined. The caller should
+        // handle this case.
+        if (!syntaxList) {
+            return undefined;
+        }
+
         var children = syntaxList.getChildren();
         var index = indexOf(children, node);
 
@@ -32,13 +41,6 @@ module ts {
             }
         });
 
-        // syntaxList should not be undefined here. If it is, there is a problem. Find out if
-        // there at least is a child that is a list.
-        if (!syntaxList) {
-            Debug.assert(findChildOfKind(node.parent, SyntaxKind.SyntaxList) !== undefined,
-                "Node of kind " + SyntaxKind[node.parent.kind] + " has no list children");
-        }
-
         return syntaxList;
     }