Local types

src/compiler/binder.ts

@@ -519,17 +519,17 @@ module ts {
                     bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.Class, SymbolFlags.ClassExcludes);
                     break;
                 case SyntaxKind.InterfaceDeclaration:
-                    bindDeclaration(<Declaration>node, SymbolFlags.Interface, SymbolFlags.InterfaceExcludes, /*isBlockScopeContainer*/ false);
+                    bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.Interface, SymbolFlags.InterfaceExcludes);
                     break;
                 case SyntaxKind.TypeAliasDeclaration:
-                    bindDeclaration(<Declaration>node, SymbolFlags.TypeAlias, SymbolFlags.TypeAliasExcludes, /*isBlockScopeContainer*/ false);
+                    bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.TypeAlias, SymbolFlags.TypeAliasExcludes);
                     break;
                 case SyntaxKind.EnumDeclaration:
                     if (isConst(node)) {
-                        bindDeclaration(<Declaration>node, SymbolFlags.ConstEnum, SymbolFlags.ConstEnumExcludes, /*isBlockScopeContainer*/ false);
+                        bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.ConstEnum, SymbolFlags.ConstEnumExcludes);
                     }
                     else {
-                        bindDeclaration(<Declaration>node, SymbolFlags.RegularEnum, SymbolFlags.RegularEnumExcludes, /*isBlockScopeContainer*/ false);
+                        bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.RegularEnum, SymbolFlags.RegularEnumExcludes);
                     }
                     break;
                 case SyntaxKind.ModuleDeclaration:

src/compiler/core.ts

@@ -129,6 +129,16 @@ module ts {
         }
     } 
 
+    export function rangeEquals<T>(array1: T[], array2: T[], pos: number, end: number) {
+        while (pos < end) {
+            if (array1[pos] !== array2[pos]) {
+                return false;
+            }
+            pos++;
+        }
+        return true;
+    }
+
     /**
      * Returns the last element of an array if non-empty, undefined otherwise.
      */

src/compiler/diagnosticInformationMap.generated.ts

@@ -548,6 +548,5 @@ module ts {
         decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." },
         Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." },
         class_expressions_are_not_currently_supported: { code: 9003, category: DiagnosticCategory.Error, key: "'class' expressions are not currently supported." },
-        class_declarations_are_only_supported_directly_inside_a_module_or_as_a_top_level_declaration: { code: 9004, category: DiagnosticCategory.Error, key: "'class' declarations are only supported directly inside a module or as a top level declaration." },
     };
 }

src/compiler/diagnosticMessages.json

@@ -2185,9 +2185,5 @@
     "'class' expressions are not currently supported.": {
         "category": "Error",
         "code": 9003
-    },
-    "'class' declarations are only supported directly inside a module or as a top level declaration.": {
-        "category": "Error",
-        "code": 9004
     }
 }

src/compiler/types.ts

@@ -917,7 +917,7 @@ module ts {
         _classElementBrand: any;
     }
 
-    export interface InterfaceDeclaration extends Declaration, ModuleElement {
+    export interface InterfaceDeclaration extends Declaration, Statement {
         name: Identifier;
         typeParameters?: NodeArray<TypeParameterDeclaration>;
         heritageClauses?: NodeArray<HeritageClause>;
@@ -929,7 +929,7 @@ module ts {
         types?: NodeArray<ExpressionWithTypeArguments>;
     }
 
-    export interface TypeAliasDeclaration extends Declaration, ModuleElement {
+    export interface TypeAliasDeclaration extends Declaration, Statement {
         name: Identifier;
         type: TypeNode;
     }
@@ -941,7 +941,7 @@ module ts {
         initializer?: Expression;
     }
 
-    export interface EnumDeclaration extends Declaration, ModuleElement {
+    export interface EnumDeclaration extends Declaration, Statement {
         name: Identifier;
         members: NodeArray<EnumMember>;
     }
@@ -1626,6 +1626,8 @@ module ts {
     // Class and interface types (TypeFlags.Class and TypeFlags.Interface)
     export interface InterfaceType extends ObjectType {
         typeParameters: TypeParameter[];           // Type parameters (undefined if non-generic)
+        outerTypeParameters: TypeParameter[];      // Outer type parameters (undefined if none)
+        localTypeParameters: TypeParameter[];      // Local type parameters (undefined if none)
     }
 
     export interface InterfaceTypeWithBaseTypes extends InterfaceType {

tests/baselines/reference/classDeclarationBlockScoping1.symbols

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/classDeclarationBlockScoping1.ts ===
+class C {
+>C : Symbol(C, Decl(classDeclarationBlockScoping1.ts, 0, 0))
+}
+
+{
+    class C {
+>C : Symbol(C, Decl(classDeclarationBlockScoping1.ts, 3, 1))
+    }
+}

tests/baselines/reference/classDeclarationBlockScoping1.types

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/classDeclarationBlockScoping1.ts ===
+class C {
+>C : C
+}
+
+{
+    class C {
+>C : C
+    }
+}

tests/baselines/reference/classDeclarationBlockScoping2.symbols

@@ -0,0 +1,22 @@
+=== tests/cases/compiler/classDeclarationBlockScoping2.ts ===
+function f() {
+>f : Symbol(f, Decl(classDeclarationBlockScoping2.ts, 0, 0))
+
+    class C {}
+>C : Symbol(C, Decl(classDeclarationBlockScoping2.ts, 0, 14))
+
+    var c1 = C;
+>c1 : Symbol(c1, Decl(classDeclarationBlockScoping2.ts, 2, 7))
+>C : Symbol(C, Decl(classDeclarationBlockScoping2.ts, 0, 14))
+    {
+        class C {}
+>C : Symbol(C, Decl(classDeclarationBlockScoping2.ts, 3, 5))
+
+        var c2 = C;
+>c2 : Symbol(c2, Decl(classDeclarationBlockScoping2.ts, 5, 11))
+>C : Symbol(C, Decl(classDeclarationBlockScoping2.ts, 3, 5))
+    }
+    return C === c1;
+>C : Symbol(C, Decl(classDeclarationBlockScoping2.ts, 0, 14))
+>c1 : Symbol(c1, Decl(classDeclarationBlockScoping2.ts, 2, 7))
+}

tests/baselines/reference/classDeclarationBlockScoping2.types

@@ -0,0 +1,23 @@
+=== tests/cases/compiler/classDeclarationBlockScoping2.ts ===
+function f() {
+>f : () => boolean
+
+    class C {}
+>C : C
+
+    var c1 = C;
+>c1 : typeof C
+>C : typeof C
+    {
+        class C {}
+>C : C
+
+        var c2 = C;
+>c2 : typeof C
+>C : typeof C
+    }
+    return C === c1;
+>C === c1 : boolean
+>C : typeof C
+>c1 : typeof C
+}

tests/baselines/reference/classExpressionTest1.symbols

@@ -0,0 +1,35 @@
+=== tests/cases/compiler/classExpressionTest1.ts ===
+function M() {
+>M : Symbol(M, Decl(classExpressionTest1.ts, 0, 0))
+
+    class C<X> {
+>C : Symbol(C, Decl(classExpressionTest1.ts, 0, 14))
+>X : Symbol(X, Decl(classExpressionTest1.ts, 1, 12))
+
+        f<T>() {
+>f : Symbol(f, Decl(classExpressionTest1.ts, 1, 16))
+>T : Symbol(T, Decl(classExpressionTest1.ts, 2, 10))
+
+            var t: T;
+>t : Symbol(t, Decl(classExpressionTest1.ts, 3, 15))
+>T : Symbol(T, Decl(classExpressionTest1.ts, 2, 10))
+
+            var x: X;
+>x : Symbol(x, Decl(classExpressionTest1.ts, 4, 15))
+>X : Symbol(X, Decl(classExpressionTest1.ts, 1, 12))
+
+            return { t, x };
+>t : Symbol(t, Decl(classExpressionTest1.ts, 5, 20))
+>x : Symbol(x, Decl(classExpressionTest1.ts, 5, 23))
+        }
+    }
+
+    var v = new C<number>();
+>v : Symbol(v, Decl(classExpressionTest1.ts, 9, 7))
+>C : Symbol(C, Decl(classExpressionTest1.ts, 0, 14))
+
+    return v.f<string>();
+>v.f : Symbol(C.f, Decl(classExpressionTest1.ts, 1, 16))
+>v : Symbol(v, Decl(classExpressionTest1.ts, 9, 7))
+>f : Symbol(C.f, Decl(classExpressionTest1.ts, 1, 16))
+}

tests/baselines/reference/classExpressionTest1.types

@@ -0,0 +1,38 @@
+=== tests/cases/compiler/classExpressionTest1.ts ===
+function M() {
+>M : () => { t: string; x: number; }
+
+    class C<X> {
+>C : C<X>
+>X : X
+
+        f<T>() {
+>f : <T>() => { t: T; x: X; }
+>T : T
+
+            var t: T;
+>t : T
+>T : T
+
+            var x: X;
+>x : X
+>X : X
+
+            return { t, x };
+>{ t, x } : { t: T; x: X; }
+>t : T
+>x : X
+        }
+    }
+
+    var v = new C<number>();
+>v : C<number>
+>new C<number>() : C<number>
+>C : typeof C
+
+    return v.f<string>();
+>v.f<string>() : { t: string; x: number; }
+>v.f : <T>() => { t: T; x: number; }
+>v : C<number>
+>f : <T>() => { t: T; x: number; }
+}

tests/baselines/reference/classInsideBlock.symbols

@@ -0,0 +1,7 @@
+=== tests/cases/conformance/classes/classDeclarations/classInsideBlock.ts ===
+function foo() {
+>foo : Symbol(foo, Decl(classInsideBlock.ts, 0, 0))
+
+    class C { }
+>C : Symbol(C, Decl(classInsideBlock.ts, 0, 16))
+}

tests/baselines/reference/classInsideBlock.types

@@ -0,0 +1,7 @@
+=== tests/cases/conformance/classes/classDeclarations/classInsideBlock.ts ===
+function foo() {
+>foo : () => void
+
+    class C { }
+>C : C
+}

tests/baselines/reference/functionsWithModifiersInBlocks1.errors.txt

@@ -4,12 +4,11 @@ tests/cases/compiler/functionsWithModifiersInBlocks1.ts(2,25): error TS1184: An
 tests/cases/compiler/functionsWithModifiersInBlocks1.ts(3,4): error TS1184: Modifiers cannot appear here.
 tests/cases/compiler/functionsWithModifiersInBlocks1.ts(3,20): error TS2393: Duplicate function implementation.
 tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,4): error TS1184: Modifiers cannot appear here.
-tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,12): error TS1029: 'export' modifier must precede 'declare' modifier.
 tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,28): error TS2393: Duplicate function implementation.
 tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,32): error TS1184: An implementation cannot be declared in ambient contexts.
 
 
-==== tests/cases/compiler/functionsWithModifiersInBlocks1.ts (9 errors) ====
+==== tests/cases/compiler/functionsWithModifiersInBlocks1.ts (8 errors) ====
     {
        declare function f() { }
        ~~~~~~~
@@ -26,8 +25,6 @@ tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,32): error TS1184: An
        declare export function f() { }
        ~~~~~~~
 !!! error TS1184: Modifiers cannot appear here.
-               ~~~~~~
-!!! error TS1029: 'export' modifier must precede 'declare' modifier.
                                ~
 !!! error TS2393: Duplicate function implementation.
                                    ~

tests/baselines/reference/generatorTypeCheck39.errors.txt

@@ -1,27 +1,18 @@
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(5,5): error TS1129: Statement expected.
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(5,6): error TS2346: Supplied parameters do not match any signature of call target.
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(5,16): error TS2304: Cannot find name 'yield'.
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(5,22): error TS1005: ',' expected.
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(9,1): error TS1128: Declaration or statement expected.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(5,16): error TS1163: A 'yield' expression is only allowed in a generator body.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(7,13): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts (5 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts (2 errors) ====
     function decorator(x: any) {
         return y => { };
     }
     function* g() {
         @decorator(yield 0)
-        ~
-!!! error TS1129: Statement expected.
-         ~~~~~~~~~~~~~~~~~~
-!!! error TS2346: Supplied parameters do not match any signature of call target.
                    ~~~~~
-!!! error TS2304: Cannot find name 'yield'.
-                         ~
-!!! error TS1005: ',' expected.
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
         class C {
             x = yield 0;
+                ~~~~~
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
         }
-    }
-    ~
-!!! error TS1128: Declaration or statement expected.
+    }