Readonly properties and index signatures

src/compiler/diagnosticMessages.json

@@ -67,6 +67,10 @@
         "category": "Error",
         "code": 1023
     },
+    "'readonly' modifier can only appear on a property declaration or index signature.": {
+        "category": "Error",
+        "code": 1024
+    },
     "Accessibility modifier already seen.": {
         "category": "Error",
         "code": 1028
@@ -203,6 +207,14 @@
         "category": "Error",
         "code": 1068
     },
+    "'{0}' modifier cannot appear on a type member.": {
+        "category": "Error",
+        "code": 1070
+    },
+    "'{0}' modifier cannot appear on an index signature.": {
+        "category": "Error",
+        "code": 1071
+    },
     "A '{0}' modifier cannot be used with an import declaration.": {
         "category": "Error",
         "code": 1079
@@ -423,10 +435,6 @@
         "category": "Error",
         "code": 1144
     },
-    "Modifiers not permitted on index signature members.": {
-        "category": "Error",
-        "code": 1145
-    },
     "Declaration expected.": {
         "category": "Error",
         "code": 1146
@@ -987,6 +995,10 @@
         "category": "Error",
         "code": 2342
     },
+    "Property '{0}' is read-only in type '{1}' but writable in type '{2}'.": {
+        "category": "Error",
+        "code": 2343
+    },
     "Type '{0}' does not satisfy the constraint '{1}'.": {
         "category": "Error",
         "code": 2344
@@ -1075,6 +1087,10 @@
         "category": "Error",
         "code": 2365
     },
+    "Index signature is read-only in type '{0}' but writable in type '{1}'.": {
+        "category": "Error",
+        "code": 2366
+    },
     "Type parameter name cannot be '{0}'": {
         "category": "Error",
         "code": 2368
@@ -1379,11 +1395,11 @@
         "category": "Error",
         "code": 2448
     },
-    "The operand of an increment or decrement operator cannot be a constant.": {
+    "The operand of an increment or decrement operator cannot be a constant or a read-only property.": {
         "category": "Error",
         "code": 2449
     },
-    "Left-hand side of assignment expression cannot be a constant.": {
+    "Left-hand side of assignment expression cannot be a constant or a read-only property.": {
         "category": "Error",
         "code": 2450
     },
@@ -1515,11 +1531,11 @@
         "category": "Error",
         "code": 2484
     },
-    "The left-hand side of a 'for...of' statement cannot be a previously defined constant.": {
+    "The left-hand side of a 'for...of' statement cannot be a constant or a read-only property.": {
         "category": "Error",
         "code": 2485
     },
-    "The left-hand side of a 'for...in' statement cannot be a previously defined constant.": {
+    "The left-hand side of a 'for...in' statement cannot be a constant or a read-only property.": {
         "category": "Error",
         "code": 2486
     },

src/compiler/parser.ts

@@ -1192,7 +1192,7 @@ namespace ts {
                 case ParsingContext.SwitchClauses:
                     return token === SyntaxKind.CaseKeyword || token === SyntaxKind.DefaultKeyword;
                 case ParsingContext.TypeMembers:
-                    return isStartOfTypeMember();
+                    return lookAhead(isTypeMemberStart);
                 case ParsingContext.ClassMembers:
                     // We allow semicolons as class elements (as specified by ES6) as long as we're
                     // not in error recovery.  If we're in error recovery, we don't want an errant
@@ -2233,13 +2233,13 @@ namespace ts {
             return finishNode(node);
         }
 
-        function parsePropertyOrMethodSignature(): PropertySignature | MethodSignature {
-            const fullStart = scanner.getStartPos();
+        function parsePropertyOrMethodSignature(fullStart: number, modifiers: ModifiersArray): PropertySignature | MethodSignature {
             const name = parsePropertyName();
             const questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
 
             if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) {
                 const method = <MethodSignature>createNode(SyntaxKind.MethodSignature, fullStart);
+                setModifiers(method, modifiers);
                 method.name = name;
                 method.questionToken = questionToken;
 
@@ -2251,6 +2251,7 @@ namespace ts {
             }
             else {
                 const property = <PropertySignature>createNode(SyntaxKind.PropertySignature, fullStart);
+                setModifiers(property, modifiers);
                 property.name = name;
                 property.questionToken = questionToken;
                 property.type = parseTypeAnnotation();
@@ -2267,86 +2268,51 @@ namespace ts {
             }
         }
 
-        function isStartOfTypeMember(): boolean {
-            switch (token) {
-                case SyntaxKind.OpenParenToken:
-                case SyntaxKind.LessThanToken:
-                case SyntaxKind.OpenBracketToken: // Both for indexers and computed properties
-                    return true;
-                default:
-                    if (isModifierKind(token)) {
-                        const result = lookAhead(isStartOfIndexSignatureDeclaration);
-                        if (result) {
-                            return result;
-                        }
-                    }
-
-                    return isLiteralPropertyName() && lookAhead(isTypeMemberWithLiteralPropertyName);
+        function isTypeMemberStart(): boolean {
+            let idToken: SyntaxKind;
+            // Return true if we have the start of a signature member
+            if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) {
+                return true;
             }
-        }
-
-        function isStartOfIndexSignatureDeclaration() {
+            // Eat up all modifiers, but hold on to the last one in case it is actually an identifier
             while (isModifierKind(token)) {
+                idToken = token;
                 nextToken();
             }
-
-            return isIndexSignature();
-        }
-
-        function isTypeMemberWithLiteralPropertyName() {
-            nextToken();
-            return token === SyntaxKind.OpenParenToken ||
-                token === SyntaxKind.LessThanToken ||
-                token === SyntaxKind.QuestionToken ||
-                token === SyntaxKind.ColonToken ||
-                canParseSemicolon();
+            // Index signatures and computed property names are type members
+            if (token === SyntaxKind.OpenBracketToken) {
+                return true;
+            }
+            // Try to get the first property-like token following all modifiers
+            if (isLiteralPropertyName()) {
+                idToken = token;
+                nextToken();
+            }
+            // If we were able to get any potential identifier, check that it is
+            // the start of a member declaration
+            if (idToken) {
+                return token === SyntaxKind.OpenParenToken ||
+                    token === SyntaxKind.LessThanToken ||
+                    token === SyntaxKind.QuestionToken ||
+                    token === SyntaxKind.ColonToken ||
+                    canParseSemicolon();
+            }
+            return false;
         }
 
         function parseTypeMember(): TypeElement {
-            switch (token) {
-                case SyntaxKind.OpenParenToken:
-                case SyntaxKind.LessThanToken:
-                    return parseSignatureMember(SyntaxKind.CallSignature);
-                case SyntaxKind.OpenBracketToken:
-                    // Indexer or computed property
-                    return isIndexSignature()
-                        ? parseIndexSignatureDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined)
-                        : parsePropertyOrMethodSignature();
-                case SyntaxKind.NewKeyword:
-                    if (lookAhead(isStartOfConstructSignature)) {
-                        return parseSignatureMember(SyntaxKind.ConstructSignature);
-                    }
-                // fall through.
-                case SyntaxKind.StringLiteral:
-                case SyntaxKind.NumericLiteral:
-                    return parsePropertyOrMethodSignature();
-                default:
-                    // Index declaration as allowed as a type member.  But as per the grammar,
-                    // they also allow modifiers. So we have to check for an index declaration
-                    // that might be following modifiers. This ensures that things work properly
-                    // when incrementally parsing as the parser will produce the Index declaration
-                    // if it has the same text regardless of whether it is inside a class or an
-                    // object type.
-                    if (isModifierKind(token)) {
-                        const result = tryParse(parseIndexSignatureWithModifiers);
-                        if (result) {
-                            return result;
-                        }
-                    }
-
-                    if (tokenIsIdentifierOrKeyword(token)) {
-                        return parsePropertyOrMethodSignature();
-                    }
+            if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) {
+                return parseSignatureMember(SyntaxKind.CallSignature);
             }
-        }
-
-        function parseIndexSignatureWithModifiers() {
-            const fullStart = scanner.getStartPos();
-            const decorators = parseDecorators();
+            if (token === SyntaxKind.NewKeyword && lookAhead(isStartOfConstructSignature)) {
+                return parseSignatureMember(SyntaxKind.ConstructSignature);
+            }
+            const fullStart = getNodePos();
             const modifiers = parseModifiers();
-            return isIndexSignature()
-                ? parseIndexSignatureDeclaration(fullStart, decorators, modifiers)
-                : undefined;
+            if (isIndexSignature()) {
+                return parseIndexSignatureDeclaration(fullStart, /*decorators*/ undefined, modifiers);
+            }
+            return parsePropertyOrMethodSignature(fullStart, modifiers);
         }
 
         function isStartOfConstructSignature() {
@@ -4423,6 +4389,7 @@ namespace ts {
                     case SyntaxKind.PrivateKeyword:
                     case SyntaxKind.ProtectedKeyword:
                     case SyntaxKind.PublicKeyword:
+                    case SyntaxKind.ReadonlyKeyword:
                         nextToken();
                         // ASI takes effect for this modifier.
                         if (scanner.hasPrecedingLineBreak()) {
@@ -4505,6 +4472,7 @@ namespace ts {
                 case SyntaxKind.PrivateKeyword:
                 case SyntaxKind.ProtectedKeyword:
                 case SyntaxKind.StaticKeyword:
+                case SyntaxKind.ReadonlyKeyword:
                     // When these don't start a declaration, they may be the start of a class member if an identifier
                     // immediately follows. Otherwise they're an identifier in an expression statement.
                     return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
@@ -4586,6 +4554,7 @@ namespace ts {
                 case SyntaxKind.PublicKeyword:
                 case SyntaxKind.AbstractKeyword:
                 case SyntaxKind.StaticKeyword:
+                case SyntaxKind.ReadonlyKeyword:
                 case SyntaxKind.GlobalKeyword:
                     if (isStartOfDeclaration()) {
                         return parseDeclaration();
@@ -4874,6 +4843,7 @@ namespace ts {
                 case SyntaxKind.PrivateKeyword:
                 case SyntaxKind.ProtectedKeyword:
                 case SyntaxKind.StaticKeyword:
+                case SyntaxKind.ReadonlyKeyword:
                     return true;
                 default:
                     return false;

src/compiler/program.ts

@@ -857,6 +857,7 @@ namespace ts {
                                 case SyntaxKind.PublicKeyword:
                                 case SyntaxKind.PrivateKeyword:
                                 case SyntaxKind.ProtectedKeyword:
+                                case SyntaxKind.ReadonlyKeyword:
                                 case SyntaxKind.DeclareKeyword:
                                     diagnostics.push(createDiagnosticForNode(modifier, Diagnostics._0_can_only_be_used_in_a_ts_file, tokenToString(modifier.kind)));
                                     return true;

src/compiler/scanner.ts

@@ -93,6 +93,7 @@ namespace ts {
         "private": SyntaxKind.PrivateKeyword,
         "protected": SyntaxKind.ProtectedKeyword,
         "public": SyntaxKind.PublicKeyword,
+        "readonly": SyntaxKind.ReadonlyKeyword,
         "require": SyntaxKind.RequireKeyword,
         "global": SyntaxKind.GlobalKeyword,
         "return": SyntaxKind.ReturnKeyword,

src/compiler/types.ts

@@ -163,6 +163,7 @@ namespace ts {
         IsKeyword,
         ModuleKeyword,
         NamespaceKeyword,
+        ReadonlyKeyword,
         RequireKeyword,
         NumberKeyword,
         SetKeyword,
@@ -369,32 +370,32 @@ namespace ts {
     }
 
     export const enum NodeFlags {
-        None =              0,
-        Export =            1 << 1,  // Declarations
-        Ambient =           1 << 2,  // Declarations
-        Public =            1 << 3,  // Property/Method
-        Private =           1 << 4,  // Property/Method
-        Protected =         1 << 5,  // Property/Method
-        Static =            1 << 6,  // Property/Method
-        Abstract =          1 << 7,  // Class/Method/ConstructSignature
-        Async =             1 << 8,  // Property/Method/Function
-        Default =           1 << 9,  // Function/Class (export default declaration)
-        MultiLine =         1 << 10,  // Multi-line array or object literal
-        Synthetic =         1 << 11,  // Synthetic node (for full fidelity)
-        DeclarationFile =   1 << 12,  // Node is a .d.ts file
-        Let =               1 << 13,  // Variable declaration
-        Const =             1 << 14,  // Variable declaration
-        OctalLiteral =      1 << 15,  // Octal numeric literal
-        Namespace =         1 << 16,  // Namespace declaration
-        ExportContext =     1 << 17,  // Export context (initialized by binding)
-        ContainsThis =      1 << 18,  // Interface contains references to "this"
-        HasImplicitReturn =     1 << 19,  // If function implicitly returns on one of codepaths (initialized by binding)
-        HasExplicitReturn =     1 << 20,  // If function has explicit reachable return on one of codepaths (initialized by binding)
-        GlobalAugmentation =    1 << 21,  // Set if module declaration is an augmentation for the global scope
-        Modifier = Export | Ambient | Public | Private | Protected | Static | Abstract | Default | Async,
+        None =               0,
+        Export =             1 << 1,  // Declarations
+        Ambient =            1 << 2,  // Declarations
+        Public =             1 << 3,  // Property/Method
+        Private =            1 << 4,  // Property/Method
+        Protected =          1 << 5,  // Property/Method
+        Static =             1 << 6,  // Property/Method
+        Readonly =           1 << 7,  // Property/Method
+        Abstract =           1 << 8,  // Class/Method/ConstructSignature
+        Async =              1 << 9,  // Property/Method/Function
+        Default =            1 << 10,  // Function/Class (export default declaration)
+        MultiLine =          1 << 11,  // Multi-line array or object literal
+        Synthetic =          1 << 12,  // Synthetic node (for full fidelity)
+        DeclarationFile =    1 << 13,  // Node is a .d.ts file
+        Let =                1 << 14,  // Variable declaration
+        Const =              1 << 15,  // Variable declaration
+        OctalLiteral =       1 << 16,  // Octal numeric literal
+        Namespace =          1 << 17,  // Namespace declaration
+        ExportContext =      1 << 18,  // Export context (initialized by binding)
+        ContainsThis =       1 << 19,  // Interface contains references to "this"
+        HasImplicitReturn =  1 << 20,  // If function implicitly returns on one of codepaths (initialized by binding)
+        HasExplicitReturn =  1 << 21,  // If function has explicit reachable return on one of codepaths (initialized by binding)
+        GlobalAugmentation = 1 << 22,  // Set if module declaration is an augmentation for the global scope
+        Modifier = Export | Ambient | Public | Private | Protected | Static | Readonly | Abstract | Default | Async,
         AccessibilityModifier = Public | Private | Protected,
         BlockScoped = Let | Const,
-
         ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn
     }
 
@@ -2071,6 +2072,7 @@ namespace ts {
         resolvedAwaitedType?: Type;       // Cached awaited type of type node
         resolvedSignature?: Signature;    // Cached signature of signature node or call expression
         resolvedSymbol?: Symbol;          // Cached name resolution result
+        resolvedIndexInfo?: IndexInfo;    // Cached indexing info resolution result
         flags?: NodeCheckFlags;           // Set of flags specific to Node
         enumMemberValue?: number;         // Constant value of enum member
         isVisible?: boolean;              // Is this node visible
@@ -2178,8 +2180,8 @@ namespace ts {
         declaredProperties: Symbol[];              // Declared members
         declaredCallSignatures: Signature[];       // Declared call signatures
         declaredConstructSignatures: Signature[];  // Declared construct signatures
-        declaredStringIndexType: Type;             // Declared string index type
-        declaredNumberIndexType: Type;             // Declared numeric index type
+        declaredStringIndexInfo: IndexInfo;        // Declared string indexing info
+        declaredNumberIndexInfo: IndexInfo;        // Declared numeric indexing info
     }
 
     // Type references (TypeFlags.Reference). When a class or interface has type parameters or
@@ -2231,8 +2233,8 @@ namespace ts {
         properties: Symbol[];              // Properties
         callSignatures: Signature[];       // Call signatures of type
         constructSignatures: Signature[];  // Construct signatures of type
-        stringIndexType?: Type;            // String index type
-        numberIndexType?: Type;            // Numeric index type
+        stringIndexInfo?: IndexInfo;       // String indexing info
+        numberIndexInfo?: IndexInfo;       // Numeric indexing info
     }
 
     /* @internal */
@@ -2295,6 +2297,12 @@ namespace ts {
         Number,
     }
 
+    export interface IndexInfo {
+        type: Type;
+        isReadonly: boolean;
+        declaration?: SignatureDeclaration;
+    }
+
     /* @internal */
     export interface TypeMapper {
         (t: TypeParameter): Type;