microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-19 20:37:00 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Clean up and address CR feedback

Browse Source
This commit is contained in:
Jason Freeman
2015-07-14 13:44:40 -07:00
parent 6f94314774
commit 6fc08ea3e6
3 changed files with 25 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
src/compiler/checker.ts
View File

@@ -3943,7 +3943,7 @@ namespace ts {
let id = getTypeListId(elementTypes);
let type = tupleTypes[id];
if (!type) {
type = tupleTypes[id] = <TupleType>createObjectType(TypeFlags.Tuple);
type = tupleTypes[id] = <TupleType>createObjectType(TypeFlags.Tuple | getWideningFlagsOfTypes(elementTypes));
type.elementTypes = elementTypes;
}
return type;
@@ -5300,7 +5300,7 @@ namespace ts {
* Prefer using isTupleLikeType() unless the use of `elementTypes` is required.
*/
function isTupleType(type: Type): type is TupleType {
return (type.flags & TypeFlags.Tuple) && !!(<TupleType>type).elementTypes;
return !!(type.flags & TypeFlags.Tuple);
}
function getWidenedTypeOfObjectLiteral(type: Type): Type {
@@ -5348,31 +5348,33 @@ namespace ts {
return type;
}
function reportWideningErrorsInType(type: Type, expression: Expression): boolean {
/**
* Reports implicit any errors that occur as a result of widening 'null' and 'undefined'
* to 'any'. A call to reportWideningErrorsInType is normally accompanied by a call to
* getWidenedType. But in some cases getWidenedType is called without reporting errors
* (type argument inference is an example).
*
* The return value indicates whether an error was in fact reported. The particular circumstances
* are on a best effort basis. Currently, if the null or undefined that causes widening is inside
* an object literal property (arbitrarily deeply), this function reports an error. If no error is
* reported, reportImplicitAnyError is a suitable fallback to report a general error.
*/
function reportWideningErrorsInType(type: Type): boolean {
let errorReported = false;
if (type.flags & TypeFlags.Union) {
for (let t of (<UnionType>type).types) {
if (reportWideningErrorsInType(t, expression)) {
if (reportWideningErrorsInType(t)) {
errorReported = true;
}
}
}
if (isArrayType(type)) {
return reportWideningErrorsInType((<TypeReference>type).typeArguments[0], expression);
return reportWideningErrorsInType((<TypeReference>type).typeArguments[0]);
}
if (isTupleType(type)) {
let { elementTypes } = type;
for (let i = 0; i < elementTypes.length; i++) {
let t = elementTypes[i];
if (t.flags & TypeFlags.ContainsUndefinedOrNull) {
if (reportWideningErrorsInType(t, expression)) {
errorReported = true;
}
else if (expression.kind === SyntaxKind.ArrayLiteralExpression) {
let element = (<ArrayLiteralExpression>expression).elements[i];
error(element, Diagnostics.Array_element_at_index_0_implicitly_has_an_1_type, i, typeToString(getWidenedType(t)));
errorReported = true;
}
for (let t of type.elementTypes) {
if (reportWideningErrorsInType(t)) {
errorReported = true;
}
}
}
@@ -5380,7 +5382,7 @@ namespace ts {
for (let p of getPropertiesOfObjectType(type)) {
let t = getTypeOfSymbol(p);
if (t.flags & TypeFlags.ContainsUndefinedOrNull) {
if (!reportWideningErrorsInType(t, expression)) {
if (!reportWideningErrorsInType(t)) {
error(p.valueDeclaration, Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, p.name, typeToString(getWidenedType(t)));
}
errorReported = true;
@@ -5425,7 +5427,7 @@ namespace ts {
function reportErrorsFromWidening(declaration: Declaration, type: Type) {
if (produceDiagnostics && compilerOptions.noImplicitAny && type.flags & TypeFlags.ContainsUndefinedOrNull) {
// Report implicit any error within type if possible, otherwise report error on declaration
if (!reportWideningErrorsInType(type, declaration.kind === SyntaxKind.VariableDeclaration && (<VariableDeclaration>declaration).initializer)) {
if (!reportWideningErrorsInType(type)) {
reportImplicitAnyError(declaration, type);
}
}
@@ -6801,7 +6803,6 @@ namespace ts {
let hasSpreadElement = false;
let elementTypes: Type[] = [];
let inDestructuringPattern = isAssignmentTarget(node);
let typeFlags: TypeFlags;
for (let e of elements) {
if (inDestructuringPattern && e.kind === SyntaxKind.SpreadElementExpression) {
// Given the following situation:
@@ -6821,23 +6822,21 @@ namespace ts {
(languageVersion >= ScriptTarget.ES6 ? getElementTypeOfIterable(restArrayType, /*errorNode*/ undefined) : undefined);
if (restElementType) {
elementTypes.push(restElementType);
typeFlags |= restElementType.flags;
}
}
else {
let type = checkExpression(e, contextualMapper);
elementTypes.push(type);
typeFlags |= type.flags;
}
hasSpreadElement = hasSpreadElement || e.kind === SyntaxKind.SpreadElementExpression;
}
if (!hasSpreadElement) {
let contextualType = getContextualType(node);
if (contextualType && contextualTypeIsTupleLikeType(contextualType) || inDestructuringPattern) {
return addTypeFlags(createTupleType(elementTypes), typeFlags & TypeFlags.RequiresWidening);
return createTupleType(elementTypes);
}
}
return addTypeFlags(createArrayType(getUnionType(elementTypes)), typeFlags & TypeFlags.RequiresWidening);
return createArrayType(getUnionType(elementTypes));
}
function isNumericName(name: DeclarationName): boolean {
@@ -6953,7 +6952,8 @@ namespace ts {
let stringIndexType = getIndexType(IndexKind.String);
let numberIndexType = getIndexType(IndexKind.Number);
let result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexType, numberIndexType);
return addTypeFlags(result, TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | (typeFlags & TypeFlags.ContainsUndefinedOrNull));
result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | (typeFlags & TypeFlags.ContainsUndefinedOrNull);
return result;
function getIndexType(kind: IndexKind) {
if (contextualType && contextualTypeHasIndexSignature(contextualType, kind)) {
@@ -6979,11 +6979,6 @@ namespace ts {
}
}
function addTypeFlags(type: Type, flags: TypeFlags): Type {
type.flags |= flags;
return type;
}
function checkJsxSelfClosingElement(node: JsxSelfClosingElement) {
checkJsxOpeningLikeElement(node);
return jsxElementType || anyType;

1
src/compiler/diagnosticInformationMap.generated.ts
View File

@@ -589,7 +589,6 @@ namespace ts {
Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7024, category: DiagnosticCategory.Error, key: "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." },
Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type: { code: 7025, category: DiagnosticCategory.Error, key: "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type." },
JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: { code: 7026, category: DiagnosticCategory.Error, key: "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists" },
Array_element_at_index_0_implicitly_has_an_1_type: { code: 7027, category: DiagnosticCategory.Error, key: "Array element at index {0} implicitly has an '{1}' type." },
You_cannot_rename_this_element: { code: 8000, category: DiagnosticCategory.Error, key: "You cannot rename this element." },
You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: DiagnosticCategory.Error, key: "You cannot rename elements that are defined in the standard TypeScript library." },
import_can_only_be_used_in_a_ts_file: { code: 8002, category: DiagnosticCategory.Error, key: "'import ... =' can only be used in a .ts file." },

8
src/compiler/diagnosticMessages.json
View File

@@ -2347,14 +2347,6 @@
"category": "Error",
"code": 7026
},
"JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists": {
"category": "Error",
"code": 7026
},
"Array element at index {0} implicitly has an '{1}' type.": {
"category": "Error",
"code": 7027
},
"You cannot rename this element.": {