Allow analyzer to distinguish unresolved types from dynamic.

pkg/analyzer/lib/src/generated/constant.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.constant;
 
 import 'dart:collection';
@@ skipping 532 matching lines @@
    */
   void _computeValueFor(AstNode constNode) {
     beforeComputeValue(constNode);
     if (constNode is VariableDeclaration) {
       VariableDeclaration declaration = constNode;
       VariableElement element = declaration.element;
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, element.source);
       DartObjectImpl dartObject = declaration.initializer.accept(createConstantVisitor(errorReporter));
       if (dartObject != null) {
-        if (!dartObject.isNull && !dartObject.type.isSubtypeOf(element.type)) {
+        if (!_runtimeTypeMatch(dartObject, element.type)) {
           errorReporter.reportErrorForNode(
               CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH,
               declaration, [dartObject.type, element.type]);
         }
       }
       (element as VariableElementImpl).evaluationResult = new EvaluationResultImpl.con2(dartObject, errorListener.errors);
     } else if (constNode is InstanceCreationExpression) {
       InstanceCreationExpression expression = constNode;
       ConstructorElement constructor = expression.staticElement;
       if (constructor == null) {
@@ skipping 162 matching lines @@
         beforeGetParameterDefault(baseParameter);
         EvaluationResultImpl evaluationResult = (baseParameter as ParameterElementImpl).evaluationResult;
         if (evaluationResult == null) {
           // No default was provided, so the default value is null.
           argumentValue = constantVisitor.null2;
         } else if (evaluationResult.value != null) {
           argumentValue = evaluationResult.value;
         }
       }
       if (argumentValue != null) {
-        if (!argumentValue.isNull && !argumentValue.type.isSubtypeOf(parameter.type)) {
+        if (!_runtimeTypeMatch(argumentValue, parameter.type)) {
           errorReporter.reportErrorForNode(
               CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
               errorTarget,
               [argumentValue.type, parameter.type]);
         }
         if (baseParameter.isInitializingFormal) {
           FieldElement field = (parameter as FieldFormalParameterElement).field;
           if (field != null) {
             DartType fieldType = field.type;
             if (fieldType != parameter.type) {
               // We've already checked that the argument can be assigned to the
               // parameter; we also need to check that it can be assigned to
               // the field.
-              if (!argumentValue.isNull &&
-                  !argumentValue.type.isSubtypeOf(fieldType)) {
+              if (!_runtimeTypeMatch(argumentValue, fieldType)) {
                 errorReporter.reportErrorForNode(
                     CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
                     errorTarget,
                     [argumentValue.type, fieldType]);
               }
             }
             String fieldName = field.name;
             fieldMap[fieldName] = argumentValue;
           }
         } else {
           String name = baseParameter.name;
           parameterMap[name] = argumentValue;
         }
       }
     }
     ConstantVisitor initializerVisitor = new ConstantVisitor.con2(typeProvider, parameterMap, errorReporter);
     String superName = null;
     NodeList<Expression> superArguments = null;
     for (ConstructorInitializer initializer in initializers) {
       if (initializer is ConstructorFieldInitializer) {
         ConstructorFieldInitializer constructorFieldInitializer = initializer;
         Expression initializerExpression = constructorFieldInitializer.expression;
         DartObjectImpl evaluationResult = initializerExpression.accept(initializerVisitor);
         if (evaluationResult != null) {
           String fieldName = constructorFieldInitializer.fieldName.name;
           fieldMap[fieldName] = evaluationResult;
           PropertyAccessorElement getter = definingClass.getGetter(fieldName);
           if (getter != null) {
             PropertyInducingElement field = getter.variable;
-            if (!evaluationResult.isNull &&
-                !evaluationResult.type.isSubtypeOf(field.type)) {
+            if (!_runtimeTypeMatch(evaluationResult, field.type)) {
               errorReporter.reportErrorForNode(
                   CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH,
                   node, [evaluationResult.type, fieldName, field.type]);
             }
           }
         }
       } else if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation superConstructorInvocation = initializer;
         SimpleIdentifier name = superConstructorInvocation.constructorName;
         if (name != null) {
@@ skipping 76 matching lines @@
   void _generateCycleError(List<AstNode> constantsInCycle, AstNode constant) {
     // TODO(brianwilkerson) Implement this.
   }
 
   ConstructorElement _getConstructorBase(ConstructorElement constructor) {
     while (constructor is ConstructorMember) {
       constructor = (constructor as ConstructorMember).baseElement;
     }
     return constructor;
   }
+
+  /**
+   * Check if the object [obj] matches the type [type] according
+   * to runtime type checking rules.
+   */
+  bool _runtimeTypeMatch(DartObjectImpl obj, DartType type) {
+    if (obj.isNull) {
+      return true;
+    }
+    if (type.isUndefined) {
+      return false;
+    }
+    return obj.type.isSubtypeOf(type);
+  }
 }
 
 /**
  * [AstCloner] that copies the necessary information from the AST to allow const constructor
  * initializers to be evaluated.
  */
 class ConstantValueComputer_InitializerCloner extends AstCloner {
   @override
   InstanceCreationExpression visitInstanceCreationExpression(InstanceCreationExpression node) {
     InstanceCreationExpression expression = super.visitInstanceCreationExpression(node);
@@ skipping 3755 matching lines @@
 
   @override
   String get typeName => "Type";
 
   @override
   int get hashCode => _element == null ? 0 : _element.hashCode;
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }