Allow analyzer to distinguish unresolved types from dynamic.

pkg/analyzer/test/generated/resolver_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.resolver_test;
 
 import 'dart:collection';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_junit.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
@@ skipping 419 matching lines @@
         "class C {",
         "  final A a;",
         "  const C(this.a);",
         "}",
         "var v = const C(const B());"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_fieldFormalParameterAssignableToField_fieldType_unresolved_null() {
+    // Null always passes runtime type checks, even when the type is
+    // unresolved.
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final Unresolved x;",
+        "  const A(String this.x);",
+        "}",
+        "var v = const A(null);"]));
+    resolve(source);
+    assertErrors(source, [
+        StaticWarningCode.UNDEFINED_CLASS]);
+    verify([source]);
+  }
+
   void test_fieldFormalParameterAssignableToField_implements() {
     // According to checked-mode type checking rules, a value of type B is
     // assignable to a field of type A, because B implements A (and hence is a
     // subtype of A).
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B implements A {",
         "  const B();",
         "}",
         "class C {",
@@ skipping 147 matching lines @@
         "  const A(String this.x);",
         "}",
         "var v = const A('foo');"]));
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
         StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
+  void test_fieldFormalParameterNotAssignableToField_fieldType_unresolved() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final Unresolved x;",
+        "  const A(String this.x);",
+        "}",
+        "var v = const A('foo');"]));
+    resolve(source);
+    assertErrors(source, [
+        CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
+        StaticWarningCode.UNDEFINED_CLASS]);
+    verify([source]);
+  }
+
   void test_fieldFormalParameterNotAssignableToField_extends() {
     // According to checked-mode type checking rules, a value of type A is not
     // assignable to a field of type B, because B extends A (the subtyping
     // relationship is in the wrong direction).
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "class B extends A {",
         "  const B();",
@@ skipping 121 matching lines @@
         "  const A(x) : y = x;",
         "  final int y;",
         "}",
         "var v = const A('foo');"]));
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH]);
     verify([source]);
   }
 
+  void test_fieldTypeMismatch_unresolved() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(x) : y = x;",
+        "  final Unresolved y;",
+        "}",
+        "var v = const A('foo');"]));
+    resolve(source);
+    assertErrors(source, [
+        CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH,
+        StaticWarningCode.UNDEFINED_CLASS]);
+    verify([source]);
+  }
+
   void test_fieldTypeOk_null() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(x) : y = x;",
         "  final int y;",
         "}",
         "var v = const A(null);"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_fieldTypeOk_unresolved_null() {
+    // Null always passes runtime type checks, even when the type is
+    // unresolved.
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(x) : y = x;",
+        "  final Unresolved y;",
+        "}",
+        "var v = const A(null);"]));
+    resolve(source);
+    assertErrors(source, [
+        StaticWarningCode.UNDEFINED_CLASS]);
+    verify([source]);
+  }
+
   void test_listElementTypeNotAssignable() {
     Source source = addSource(EngineTestCase.createSource(["var v = const <String> [42];"]));
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE,
         StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_mapKeyTypeNotAssignable() {
@@ skipping 19 matching lines @@
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(int x);",
         "}",
         "var v = const A(null);"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_parameterAssignable_undefined_null() {
+    // Null always passes runtime type checks, even when the type is
+    // unresolved.
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(Unresolved x);",
+        "}",
+        "var v = const A(null);"]));
+    resolve(source);
+    assertErrors(source, [
+        StaticWarningCode.UNDEFINED_CLASS]);
+    verify([source]);
+  }
+
   void test_parameterAssignable_typeSubstitution() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<T> {",
         "  const A(T x);",
         "}",
         "var v = const A<int>(3);"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_parameterNotAssignable() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(int x);",
         "}",
         "var v = const A('foo');"]));
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
         StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
+  void test_parameterNotAssignable_undefined() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(Unresolved x);",
+        "}",
+        "var v = const A('foo');"]));
+    resolve(source);
+    assertErrors(source, [
+        CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
+        StaticWarningCode.UNDEFINED_CLASS]);
+    verify([source]);
+  }
+
   void test_parameterNotAssignable_typeSubstitution() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<T> {",
         "  const A(T x);",
         "}",
         "var v = const A<int>('foo');"]));
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
         StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_topLevelVarAssignable_null() {
     Source source = addSource(EngineTestCase.createSource([
         "const int x = null;"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_topLevelVarAssignable_undefined_null() {
+    // Null always passes runtime type checks, even when the type is
+    // unresolved.
+    Source source = addSource(EngineTestCase.createSource([
+        "const Unresolved x = null;"]));
+    resolve(source);
+    assertErrors(source, [
+        StaticWarningCode.UNDEFINED_CLASS]);
+    verify([source]);
+  }
+
   void test_topLevelVarNotAssignable() {
     Source source = addSource(EngineTestCase.createSource([
         "const int x = 'foo';"]));
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH,
         StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
+
+  void test_topLevelVarNotAssignable_undefined() {
+    Source source = addSource(EngineTestCase.createSource([
+        "const Unresolved x = 'foo';"]));
+    resolve(source);
+    assertErrors(source, [
+        CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH,
+        StaticWarningCode.UNDEFINED_CLASS]);
+    verify([source]);
+  }
 }
 
 class DeclarationMatcherTest extends ResolverTestCase {
   void test_compilationUnitMatches_false_topLevelVariable() {
     _assertCompilationUnitMatches(false, EngineTestCase.createSource([
         "class C {",
         "  int m(int p) {",
         "    return p + p;",
         "  }",
         "}"]), EngineTestCase.createSource([
@@ skipping 7575 matching lines @@
   @override
   Object visitLabel(Label node) => null;
 
   @override
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
 
   @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     // In cases where we have a prefixed identifier where the prefix is dynamic, we don't want to
     // assert that the node will have a type.
-    if (node.staticType == null && identical(node.prefix.staticType, DynamicTypeImpl.instance)) {
+    if (node.staticType == null && node.prefix.staticType.isDynamic) {
       return null;
     }
     return super.visitPrefixedIdentifier(node);
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     // In cases where identifiers are being used for something other than an expressions,
     // then they can be ignored.
     AstNode parent = node.parent;
@@ skipping 372 matching lines @@
   /**
    * The type representing the built-in type 'Symbol'.
    */
   InterfaceType _symbolType;
 
   /**
    * The type representing the built-in type 'Type'.
    */
   InterfaceType _typeType;
 
+  /**
+   * The type representing typenames that can't be resolved.
+   */
+  DartType _undefinedType;
+
   @override
   InterfaceType get boolType {
     if (_boolType == null) {
       ClassElementImpl boolElement = ElementFactory.classElement2("bool", []);
       _boolType = boolElement.type;
       ConstructorElementImpl fromEnvironment = ElementFactory.constructorElement(boolElement, "fromEnvironment", true, []);
       fromEnvironment.parameters = <ParameterElement> [
           ElementFactory.requiredParameter2("name", stringType),
           ElementFactory.namedParameter2("defaultValue", _boolType)];
       fromEnvironment.factory = true;
@@ skipping 188 matching lines @@
   }
 
   @override
   InterfaceType get typeType {
     if (_typeType == null) {
       _typeType = ElementFactory.classElement2("Type", []).type;
     }
     return _typeType;
   }
 
+  @override
+  DartType get undefinedType {
+    if (_undefinedType == null) {
+      _undefinedType = UndefinedTypeImpl.instance;
+    }
+    return _undefinedType;
+  }
+
   /**
    * Initialize the numeric types. They are created as a group so that we can (a) create the right
    * hierarchy and (b) add members to them.
    */
   void _initializeNumericTypes() {
     //
     // Create the type hierarchy.
     //
     ClassElementImpl numElement = ElementFactory.classElement2("num", []);
     _numType = numElement.type;
@@ skipping 1860 matching lines @@
   runReflectiveTests(TypeResolverVisitorTest);
   runReflectiveTests(CheckedModeCompileTimeErrorCodeTest);
   runReflectiveTests(ErrorResolverTest);
   runReflectiveTests(HintCodeTest);
   runReflectiveTests(MemberMapTest);
   runReflectiveTests(NonHintCodeTest);
   runReflectiveTests(SimpleResolverTest);
   runReflectiveTests(StrictModeTest);
   runReflectiveTests(TypePropagationTest);
 }