Rename isObjectLiteralPatternWithComputedProperties

sandersn · sandersn · commit 663ee44e62ec · 2016-10-03T16:01:08.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -3179,7 +3179,7 @@ namespace ts {
                 result.pattern = pattern;
             }
             if (hasComputedProperties) {
-                result.inObjectLiteralPatternWithComputedProperties = hasComputedProperties;
+                result.isObjectLiteralPatternWithComputedProperties = hasComputedProperties;
             }
             return result;
         }
@@ -6650,7 +6650,7 @@ namespace ts {
 
             function hasExcessProperties(source: FreshObjectLiteralType, target: Type, reportErrors: boolean): boolean {
                 if (maybeTypeOfKind(target, TypeFlags.ObjectType) &&
-                    (!(target.flags & TypeFlags.ObjectType) || !(target as ObjectType).inObjectLiteralPatternWithComputedProperties)) {
+                    (!(target.flags & TypeFlags.ObjectType) || !(target as ObjectType).isObjectLiteralPatternWithComputedProperties)) {
                     for (const prop of getPropertiesOfObjectType(source)) {
                         if (!isKnownProperty(target, prop.name)) {
                             if (reportErrors) {
@@ -10311,7 +10311,7 @@ namespace ts {
                         }
                     }
                     else if (contextualTypeHasPattern &&
-                             !(contextualType.flags & TypeFlags.ObjectType && (contextualType as ObjectType).inObjectLiteralPatternWithComputedProperties)) {
+                             !(contextualType.flags & TypeFlags.ObjectType && (contextualType as ObjectType).isObjectLiteralPatternWithComputedProperties)) {
                         // If object literal is contextually typed by the implied type of a binding pattern, and if the
                         // binding pattern specifies a default value for the property, make the property optional.
                         const impliedProp = getPropertyOfType(contextualType, member.name);
@@ -10378,7 +10378,7 @@ namespace ts {
             const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : TypeFlags.FreshLiteral;
             result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | freshObjectLiteralFlag | (typeFlags & TypeFlags.PropagatingFlags);
             if (patternWithComputedProperties) {
-                result.inObjectLiteralPatternWithComputedProperties = patternWithComputedProperties;
+                result.isObjectLiteralPatternWithComputedProperties = patternWithComputedProperties;
             }
             if (inDestructuringPattern) {
                 result.pattern = node;
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2462,7 +2462,7 @@ namespace ts {
 
     // Object types (TypeFlags.ObjectType)
     export interface ObjectType extends Type {
-        inObjectLiteralPatternWithComputedProperties?: boolean;
+        isObjectLiteralPatternWithComputedProperties?: boolean;
     }
 
     // Class and interface types (TypeFlags.Class and TypeFlags.Interface)

Original file line number	Diff line number	Diff line change
`@@ -3179,7 +3179,7 @@ namespace ts {`
`3179`	`3179`	`result.pattern = pattern;`
`3180`	`3180`	`}`
`3181`	`3181`	`if (hasComputedProperties) {`
`3182`		`- result.inObjectLiteralPatternWithComputedProperties = hasComputedProperties;`
	`3182`	`+ result.isObjectLiteralPatternWithComputedProperties = hasComputedProperties;`
`3183`	`3183`	`}`
`3184`	`3184`	`return result;`
`3185`	`3185`	`}`
`@@ -6650,7 +6650,7 @@ namespace ts {`
`6650`	`6650`
`6651`	`6651`	`function hasExcessProperties(source: FreshObjectLiteralType, target: Type, reportErrors: boolean): boolean {`
`6652`	`6652`	`if (maybeTypeOfKind(target, TypeFlags.ObjectType) &&`
`6653`		`- (!(target.flags & TypeFlags.ObjectType) \|\| !(target as ObjectType).inObjectLiteralPatternWithComputedProperties)) {`
	`6653`	`+ (!(target.flags & TypeFlags.ObjectType) \|\| !(target as ObjectType).isObjectLiteralPatternWithComputedProperties)) {`
`6654`	`6654`	`for (const prop of getPropertiesOfObjectType(source)) {`
`6655`	`6655`	`if (!isKnownProperty(target, prop.name)) {`
`6656`	`6656`	`if (reportErrors) {`
`@@ -10311,7 +10311,7 @@ namespace ts {`
`10311`	`10311`	`}`
`10312`	`10312`	`}`
`10313`	`10313`	`else if (contextualTypeHasPattern &&`
`10314`		`- !(contextualType.flags & TypeFlags.ObjectType && (contextualType as ObjectType).inObjectLiteralPatternWithComputedProperties)) {`
	`10314`	`+ !(contextualType.flags & TypeFlags.ObjectType && (contextualType as ObjectType).isObjectLiteralPatternWithComputedProperties)) {`
`10315`	`10315`	`// If object literal is contextually typed by the implied type of a binding pattern, and if the`
`10316`	`10316`	`// binding pattern specifies a default value for the property, make the property optional.`
`10317`	`10317`	`const impliedProp = getPropertyOfType(contextualType, member.name);`
`@@ -10378,7 +10378,7 @@ namespace ts {`
`10378`	`10378`	`const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : TypeFlags.FreshLiteral;`
`10379`	`10379`	`result.flags \|= TypeFlags.ObjectLiteral \| TypeFlags.ContainsObjectLiteral \| freshObjectLiteralFlag \| (typeFlags & TypeFlags.PropagatingFlags);`
`10380`	`10380`	`if (patternWithComputedProperties) {`
`10381`		`- result.inObjectLiteralPatternWithComputedProperties = patternWithComputedProperties;`
	`10381`	`+ result.isObjectLiteralPatternWithComputedProperties = patternWithComputedProperties;`
`10382`	`10382`	`}`
`10383`	`10383`	`if (inDestructuringPattern) {`
`10384`	`10384`	`result.pattern = node;`
Original file line number	Diff line number	Diff line change
`@@ -2462,7 +2462,7 @@ namespace ts {`
`2462`	`2462`
`2463`	`2463`	`// Object types (TypeFlags.ObjectType)`
`2464`	`2464`	`export interface ObjectType extends Type {`
`2465`		`- inObjectLiteralPatternWithComputedProperties?: boolean;`
	`2465`	`+ isObjectLiteralPatternWithComputedProperties?: boolean;`
`2466`	`2466`	`}`
`2467`	`2467`
`2468`	`2468`	`// Class and interface types (TypeFlags.Class and TypeFlags.Interface)`