Error on inferred '{}' type.

Author: DanielRosenwasser

Diff for: src/compiler/checker.ts

@@ -6239,7 +6239,7 @@ module ts {
             return getSignatureInstantiation(signature, getInferredTypes(context));
         }
 
-        function inferTypeArguments(signature: Signature, args: Expression[], excludeArgument: boolean[]): InferenceContext {
+        function inferTypeArguments(signature: Signature, callNode: CallLikeExpression, args: Expression[], excludeArgument: boolean[]): InferenceContext {
             var typeParameters = signature.typeParameters;
             var context = createInferenceContext(typeParameters, /*inferUnionTypes*/ false);
             var inferenceMapper = createInferenceMapper(context);
@@ -6281,9 +6281,9 @@ module ts {
             // Inference has failed if the inferenceFailureType type is in list of inferences
             context.failedTypeParameterIndex = indexOf(inferredTypes, inferenceFailureType);
 
-            // Wipe out the inferenceFailureType from the array so that error recovery can work properly
             for (var i = 0; i < inferredTypes.length; i++) {
                 if (inferredTypes[i] === inferenceFailureType) {
+                    // Wipe out the inferenceFailureType from the array so that error recovery can work properly
                     inferredTypes[i] = unknownType;
                 }
             }
@@ -6529,33 +6529,48 @@ module ts {
 
                     var originalCandidate = candidates[i];
                     var inferenceResult: InferenceContext;
+                    var typeArgumentTypes: Type[];
 
                     while (true) {
                         var candidate = originalCandidate;
                         if (candidate.typeParameters) {
-                            var typeArgumentTypes: Type[];
                             var typeArgumentsAreValid: boolean;
                             if (typeArguments) {
                                 typeArgumentTypes = new Array<Type>(candidate.typeParameters.length);
                                 typeArgumentsAreValid = checkTypeArguments(candidate, typeArguments, typeArgumentTypes, /*reportErrors*/ false)
                             }
                             else {
-                                inferenceResult = inferTypeArguments(candidate, args, excludeArgument);
-                                typeArgumentsAreValid = inferenceResult.failedTypeParameterIndex < 0;
+                                inferenceResult = inferTypeArguments(candidate, node, args, excludeArgument);
                                 typeArgumentTypes = inferenceResult.inferredTypes;
+                                typeArgumentsAreValid = inferenceResult.failedTypeParameterIndex < 0;
                             }
                             if (!typeArgumentsAreValid) {
                                 break;
                             }
                             candidate = getSignatureInstantiation(candidate, typeArgumentTypes);
                         }
+
                         if (!checkApplicableSignature(node, args, candidate, relation, excludeArgument, /*reportErrors*/ false)) {
                             break;
                         }
+
                         var index = excludeArgument ? indexOf(excludeArgument, true) : -1;
                         if (index < 0) {
+
+                            // Check for type arguments inferred as '{}'.
+                            if (originalCandidate.typeParameters && inferenceResult) {
+                                for (var i = 0, len = typeArgumentTypes.length; i < len; i++) {
+                                    
+                                    if (typeArgumentTypes[i] === emptyObjectType && getInferenceCandidates(inferenceResult, i).length === 0) {
+                                        error(node, Diagnostics.Type_parameter_0_was_inferred_to_have_type,
+                                            typeToString(originalCandidate.typeParameters[i]));
+                                    }
+                                }
+                            }
+
                             return candidate;
                         }
+
                         excludeArgument[index] = false;
                     }
 

Diff for: src/compiler/core.ts

@@ -159,7 +159,7 @@ module ts {
 
     var hasOwnProperty = Object.prototype.hasOwnProperty;
 
-    export function hasProperty<T>(map: Map<T>, key: string): boolean {
+    export function hasProperty(map: Map<any>, key: string): boolean {
         return hasOwnProperty.call(map, key);
     }
 

Diff for: src/compiler/diagnosticInformationMap.generated.ts

@@ -480,6 +480,7 @@ module ts {
         _0_implicitly_has_type_any_because_it_is_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: { code: 7022, category: DiagnosticCategory.Error, key: "'{0}' implicitly has type 'any' because it is does not have a type annotation and is referenced directly or indirectly in its own initializer." },
         _0_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: 7023, category: DiagnosticCategory.Error, key: "'{0}' 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." },
         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." },
+        Type_parameter_0_was_inferred_to_have_type: { code: 7025, category: DiagnosticCategory.Error, key: "Type parameter '{0}' was inferred to have 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." },
         yield_expressions_are_not_currently_supported: { code: 9000, category: DiagnosticCategory.Error, key: "'yield' expressions are not currently supported." },

Diff for: src/compiler/diagnosticMessages.json

@@ -617,7 +617,7 @@
     },
     "Unterminated Unicode escape sequence.": {
         "category": "Error",
-        "code":  1199
+        "code": 1199
     },
     "Duplicate identifier '{0}'.": {
         "category": "Error",
@@ -1913,6 +1913,10 @@
         "category": "Error",
         "code": 7024
     },
+    "Type parameter '{0}' was inferred to have type '{}'.": {
+        "category": "Error",
+        "code": 7025
+    },
     "You cannot rename this element.": {
         "category": "Error",
         "code": 8000