Issue 28550. Fix for resynthesizing invalid elements as declared types.

pkg/analyzer/lib/src/summary/resynthesize.dart

 // Copyright (c) 2015, 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 summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
@@ skipping 1176 matching lines @@
    * The enclosing [_ReferenceInfo], or `null` for top-level elements.
    */
   final _ReferenceInfo enclosing;
 
   /**
    * The name of the entity referred to by this reference.
    */
   final String name;
 
   /**
+   * Is `true` if the [element] can be used as a declared type.
+   */
+  final bool isDeclarableType;
+
+  /**
    * The element referred to by this reference, or `null` if there is no
    * associated element (e.g. because it is a reference to an undefined
    * entity).
    */
   final Element element;
 
   /**
    * If this reference refers to a non-generic type, the type it refers to.
    * Otherwise `null`.
    */
   DartType type;
 
   /**
    * The number of type parameters accepted by the entity referred to by this
    * reference, or zero if it doesn't accept any type parameters.
    */
   final int numTypeParameters;
 
   /**
    * Create a new [_ReferenceInfo] object referring to an element called [name]
    * via the element handle [element], and having [numTypeParameters] type
    * parameters.
    *
    * For the special types `dynamic` and `void`, [specialType] should point to
    * the type itself.  Otherwise, pass `null` and the type will be computed
    * when appropriate.
    */
-  _ReferenceInfo(this.libraryResynthesizer, this.enclosing, this.name,
-      this.element, DartType specialType, this.numTypeParameters) {
+  _ReferenceInfo(
+      this.libraryResynthesizer,
+      this.enclosing,
+      this.name,
+      this.isDeclarableType,
+      this.element,
+      DartType specialType,
+      this.numTypeParameters) {
     if (specialType != null) {
       type = specialType;
     } else {
       type = _buildType(true, 0, (_) => DynamicTypeImpl.instance, const []);
     }
   }
 
   /**
    * Build a [DartType] corresponding to the result of applying some type
    * arguments to the entity referred to by this [_ReferenceInfo].  The type
@@ skipping 166 matching lines @@
 
   @override
   DartType resolveLinkedType(
       int slot, TypeParameterizedElementMixin typeParameterContext) {
     return _unitResynthesizer.buildLinkedType(slot, typeParameterContext);
   }
 
   @override
   DartType resolveTypeRef(
       EntityRef type, TypeParameterizedElementMixin typeParameterContext,
-      {bool defaultVoid: false, bool instantiateToBoundsAllowed: true}) {
+      {bool defaultVoid: false,
+      bool instantiateToBoundsAllowed: true,
+      bool declaredType: false}) {
     return _unitResynthesizer.buildType(type, typeParameterContext,
         defaultVoid: defaultVoid,
-        instantiateToBoundsAllowed: instantiateToBoundsAllowed);
+        instantiateToBoundsAllowed: instantiateToBoundsAllowed,
+        declaredType: declaredType);
   }
 }
 
 /**
  * An instance of [_UnitResynthesizer] is responsible for resynthesizing the
  * elements in a single unit from that unit's summary.
  */
 class _UnitResynthesizer {
   /**
    * The [_LibraryResynthesizer] which is being used to obtain summaries.
@@ skipping 159 matching lines @@
   }
 
   /**
    * Build a [DartType] object based on a [EntityRef].  This [DartType]
    * may refer to elements in other libraries than the library being
    * deserialized, so handles are used to avoid having to deserialize other
    * libraries in the process.
    */
   DartType buildType(
       EntityRef type, TypeParameterizedElementMixin typeParameterContext,
-      {bool defaultVoid: false, bool instantiateToBoundsAllowed: true}) {
+      {bool defaultVoid: false,
+      bool instantiateToBoundsAllowed: true,
+      bool declaredType: false}) {
     if (type == null) {
       if (defaultVoid) {
         return VoidTypeImpl.instance;
       } else {
         return DynamicTypeImpl.instance;
       }
     }
     if (type.paramReference != 0) {
       return typeParameterContext.getTypeParameterType(type.paramReference);
     } else if (type.syntheticReturnType != null) {
       FunctionElementImpl element =
           new FunctionElementImpl_forLUB(unit, typeParameterContext, type);
       return element.type;
     } else {
       DartType getTypeArgument(int i) {
         if (i < type.typeArguments.length) {
           return buildType(type.typeArguments[i], typeParameterContext);
         } else {
           return DynamicTypeImpl.instance;
         }
       }
 
       _ReferenceInfo referenceInfo = getReferenceInfo(type.reference);
+      if (declaredType && !referenceInfo.isDeclarableType) {
+        return DynamicTypeImpl.instance;
+      }
       return referenceInfo.buildType(
           instantiateToBoundsAllowed,
           type.typeArguments.length,
           getTypeArgument,
           type.implicitFunctionTypeIndices);
     }
   }
 
   UnitExplicitTopLevelAccessors buildUnitExplicitTopLevelAccessors() {
     HashMap<String, TopLevelVariableElementImpl> implicitVariables =
@@ skipping 79 matching lines @@
         containingReference = unlinkedUnit.references[index].prefixReference;
       } else {
         name = linkedUnit.references[index].name;
         containingReference = linkedUnit.references[index].containingReference;
       }
       _ReferenceInfo enclosingInfo = containingReference != 0
           ? getReferenceInfo(containingReference)
           : null;
       Element element;
       DartType type;
+      bool isDeclarableType = false;
       int numTypeParameters = linkedReference.numTypeParameters;
       if (linkedReference.kind == ReferenceKind.unresolved) {
         type = UndefinedTypeImpl.instance;
         element = null;
+        isDeclarableType = true;
       } else if (name == 'dynamic') {
         type = DynamicTypeImpl.instance;
         element = type.element;
+        isDeclarableType = true;
       } else if (name == 'void') {
         type = VoidTypeImpl.instance;
         element = type.element;
+        isDeclarableType = true;
       } else if (name == '*bottom*') {
         type = BottomTypeImpl.instance;
         element = null;
+        isDeclarableType = true;
       } else {
         List<String> locationComponents;
         if (enclosingInfo != null && enclosingInfo.element is ClassElement) {
           String identifier = _getElementIdentifier(name, linkedReference.kind);
           locationComponents =
               enclosingInfo.element.location.components.toList();
           locationComponents.add(identifier);
         } else {
           String identifier = _getElementIdentifier(name, linkedReference.kind);
           locationComponents =
               libraryResynthesizer.getReferencedLocationComponents(
                   linkedReference.dependency, linkedReference.unit, identifier);
         }
         if (!_resynthesizerContext.isStrongMode &&
             locationComponents.length == 3 &&
             locationComponents[0] == 'dart:async' &&
             locationComponents[2] == 'FutureOr') {
           type = typeProvider.dynamicType;
           numTypeParameters = 0;
         }
         ElementLocation location =
             new ElementLocationImpl.con3(locationComponents);
         if (enclosingInfo != null) {
           numTypeParameters += enclosingInfo.numTypeParameters;
         }
         switch (linkedReference.kind) {
           case ReferenceKind.classOrEnum:
             element = new ClassElementHandle(summaryResynthesizer, location);
+            isDeclarableType = true;
             break;
           case ReferenceKind.constructor:
             assert(location.components.length == 4);
             element =
                 new ConstructorElementHandle(summaryResynthesizer, location);
             break;
           case ReferenceKind.method:
             assert(location.components.length == 4);
             element = new MethodElementHandle(summaryResynthesizer, location);
             break;
           case ReferenceKind.propertyAccessor:
             assert(location.components.length == 4);
             element = new PropertyAccessorElementHandle(
                 summaryResynthesizer, location);
             break;
           case ReferenceKind.topLevelFunction:
             assert(location.components.length == 3);
             element = new FunctionElementHandle(summaryResynthesizer, location);
             break;
           case ReferenceKind.topLevelPropertyAccessor:
             element = new PropertyAccessorElementHandle(
                 summaryResynthesizer, location);
             break;
           case ReferenceKind.typedef:
             element = new FunctionTypeAliasElementHandle(
                 summaryResynthesizer, location);
+            isDeclarableType = true;
             break;
           case ReferenceKind.variable:
             Element enclosingElement = enclosingInfo.element;
             if (enclosingElement is ExecutableElement) {
               element = new _DeferredLocalVariableElement(
                   enclosingElement, linkedReference.localIndex);
             } else {
               throw new StateError('Unexpected element enclosing variable:'
                   ' ${enclosingElement.runtimeType}');
             }
             break;
           case ReferenceKind.function:
             Element enclosingElement = enclosingInfo.element;
             if (enclosingElement is VariableElement) {
               element = new _DeferredInitializerElement(enclosingElement);
             } else if (enclosingElement is ExecutableElement) {
               element = new _DeferredLocalFunctionElement(
                   enclosingElement, linkedReference.localIndex);
             } else {
               throw new StateError('Unexpected element enclosing function:'
                   ' ${enclosingElement.runtimeType}');
             }
             break;
           case ReferenceKind.prefix:
           case ReferenceKind.unresolved:
             break;
         }
       }
       result = new _ReferenceInfo(libraryResynthesizer, enclosingInfo, name,
-          element, type, numTypeParameters);
+          isDeclarableType, element, type, numTypeParameters);
       referenceInfos[index] = result;
     }
     return result;
   }
 
   Expression _buildConstExpression(ElementImpl context, UnlinkedExpr uc) {
     return new _ConstExprBuilder(this, context, uc).build();
   }
 
   /**
@@ skipping 65 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }