Report invalid types in least-common-supertype calculation

runtime/sema/check_array_expression.go

@@ -80,16 +80,8 @@ func (checker *Checker) VisitArrayExpression(arrayExpression *ast.ArrayExpressio
 	if elementType == nil {
 		// Contextually expected type is not available.
 		// Therefore, find the least common supertype of the elements.
-		elementType = LeastCommonSuperType(argumentTypes...)
-
+		elementType = checker.leastCommonSuperType(arrayExpression, argumentTypes...)
 		if elementType == InvalidType {
-			checker.report(
-				&TypeAnnotationRequiredError{
-					Cause: "cannot infer type from array literal:",
-					Pos:   arrayExpression.StartPos,
-				},
-			)
-
 			return InvalidType
 		}
 

runtime/sema/check_binary_expression.go

@@ -468,5 +468,5 @@ func (checker *Checker) checkBinaryExpressionNilCoalescing(
 		}
 	}
 
-	return LeastCommonSuperType(leftOptional.Type, rightType)
+	return checker.leastCommonSuperType(expression, leftOptional.Type, rightType)
 }

runtime/sema/check_conditional.go

@@ -128,7 +128,7 @@ func (checker *Checker) VisitConditionalExpression(expression *ast.ConditionalEx
 		return thenType
 	}
 
-	return LeastCommonSuperType(thenType, elseType)
+	return checker.leastCommonSuperType(expression, thenType, elseType)
 }
 
 // checkConditionalBranches checks two conditional branches.

runtime/sema/check_dictionary_expression.go

@@ -69,18 +69,13 @@ func (checker *Checker) VisitDictionaryExpression(expression *ast.DictionaryExpr
 	if keyType == nil && valueType == nil {
 		// Contextually expected type is not available.
 		// Therefore, find the least common supertype of the keys and values.
-		keyType = LeastCommonSuperType(keyTypes...)
-		valueType = LeastCommonSuperType(valueTypes...)
-
-		if keyType == InvalidType ||
-			valueType == InvalidType {
-			checker.report(
-				&TypeAnnotationRequiredError{
-					Cause: "cannot infer type from dictionary literal:",
-					Pos:   expression.StartPos,
-				},
-			)
+		keyType = checker.leastCommonSuperType(expression, keyTypes...)
+		if keyType == InvalidType {
+			return InvalidType
+		}
 
+		valueType = checker.leastCommonSuperType(expression, valueTypes...)
+		if valueType == InvalidType {
 			return InvalidType
 		}
 	}

runtime/sema/checker.go

@@ -2766,3 +2766,18 @@ func (checker *Checker) checkNativeModifier(isNative bool, position ast.HasPosit
 		)
 	}
 }
+
+func (checker *Checker) leastCommonSuperType(pos ast.HasPosition, types ...Type) Type {
+	elementType := LeastCommonSuperType(types...)
+
+	if elementType == InvalidType {
+		checker.report(
+			&TypeAnnotationRequiredError{
+				Cause: "cannot infer type:",
+				Pos:   pos.StartPosition(),
+			},
+		)
+	}
+
+	return elementType
+}

runtime/tests/checker/conditional_test.go

@@ -66,9 +66,10 @@ func TestCheckInvalidConditionalExpressionElse(t *testing.T) {
             let x = true ? 2 : y
 	    `)
 
-		errs := RequireCheckerErrors(t, err, 1)
+		errs := RequireCheckerErrors(t, err, 2)
 
 		assert.IsType(t, &sema.NotDeclaredError{}, errs[0])
+		assert.IsType(t, &sema.TypeAnnotationRequiredError{}, errs[1])
 
 		xType := RequireGlobalValue(t, checker.Elaboration, "x")
 		assert.Equal(t, sema.InvalidType, xType)