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

pkg/analyzer/lib/src/dart/element/element.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 analyzer.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 3864 matching lines @@
   DartType get returnType {
     if (serializedExecutable != null &&
         _declaredReturnType == null &&
         _returnType == null) {
       bool isSetter =
           serializedExecutable.kind == UnlinkedExecutableKind.setter;
       _returnType = enclosingUnit.resynthesizerContext.resolveLinkedType(
           serializedExecutable.inferredReturnTypeSlot, typeParameterContext);
       _declaredReturnType = enclosingUnit.resynthesizerContext.resolveTypeRef(
           serializedExecutable.returnType, typeParameterContext,
-          defaultVoid: isSetter && context.analysisOptions.strongMode);
+          defaultVoid: isSetter && context.analysisOptions.strongMode,
+          declaredType: true);
     }
     return _returnType ?? _declaredReturnType;
   }
 
   void set returnType(DartType returnType) {
     _assertNotResynthesized(serializedExecutable);
     _returnType = returnType;
   }
 
   @override
@@ skipping 851 matching lines @@
       for (ParameterElement parameter in parameters) {
         (parameter as ParameterElementImpl).enclosingElement = this;
       }
     }
     this._parameters = parameters;
   }
 
   @override
   DartType get returnType {
     if (_unlinkedTypedef != null && _returnType == null) {
-      _returnType = enclosingUnit.resynthesizerContext
-          .resolveTypeRef(_unlinkedTypedef.returnType, this);
+      _returnType = enclosingUnit.resynthesizerContext.resolveTypeRef(
+          _unlinkedTypedef.returnType, this,
+          declaredType: true);
     }
     return _returnType;
   }
 
   void set returnType(DartType returnType) {
     _assertNotResynthesized(_unlinkedTypedef);
     _returnType = returnType;
   }
 
   @override
@@ skipping 2125 matching lines @@
       return _unlinkedVariable.nameOffset;
     }
     return offset;
   }
 
   @override
   DartType get type {
     if (_unlinkedVariable != null && _declaredType == null && _type == null) {
       _type = enclosingUnit.resynthesizerContext.resolveLinkedType(
           _unlinkedVariable.inferredTypeSlot, typeParameterContext);
-      _declaredType = enclosingUnit.resynthesizerContext
-          .resolveTypeRef(_unlinkedVariable.type, typeParameterContext);
+      _declaredType = enclosingUnit.resynthesizerContext.resolveTypeRef(
+          _unlinkedVariable.type, typeParameterContext,
+          declaredType: true);
     }
     return super.type;
   }
 
   void set type(DartType type) {
     _assertNotResynthesized(_unlinkedVariable);
     _type = type;
   }
 
   /**
@@ skipping 466 matching lines @@
         parameterTypeElement.returnType = enclosingUnit.resynthesizerContext
             .resolveTypeRef(_unlinkedParam.type, typeParameterContext);
         FunctionTypeImpl parameterType =
             new FunctionTypeImpl.elementWithNameAndArgs(parameterTypeElement,
                 null, typeParameterContext.allTypeParameterTypes, false);
         parameterTypeElement.type = parameterType;
         _type = parameterType;
       } else {
         _type = enclosingUnit.resynthesizerContext.resolveLinkedType(
             _unlinkedParam.inferredTypeSlot, typeParameterContext);
-        _declaredType = enclosingUnit.resynthesizerContext
-            .resolveTypeRef(_unlinkedParam.type, typeParameterContext);
+        _declaredType = enclosingUnit.resynthesizerContext.resolveTypeRef(
+            _unlinkedParam.type, typeParameterContext,
+            declaredType: true);
       }
     }
   }
 
   /**
    * Create and return [ParameterElement]s for the given [unlinkedParameters].
    */
   static List<ParameterElement> resynthesizeList(
       List<UnlinkedParam> unlinkedParameters, ElementImpl enclosingElement,
       {bool synthetic: false}) {
@@ skipping 537 matching lines @@
 
   /**
    * Resolve an [EntityRef] into a type.  If the reference is
    * unresolved, return [DynamicTypeImpl.instance].
    *
    * TODO(paulberry): or should we have a class representing an
    * unresolved type, for consistency with the full element model?
    */
   DartType resolveTypeRef(
       EntityRef type, TypeParameterizedElementMixin typeParameterContext,
-      {bool defaultVoid: false, bool instantiateToBoundsAllowed: true});
+      {bool defaultVoid: false,
+      bool instantiateToBoundsAllowed: true,
+      bool declaredType: false});
 }
 
 /**
  * A concrete implementation of a [ShowElementCombinator].
  */
 class ShowElementCombinatorImpl implements ShowElementCombinator {
   /**
    * The unlinked representation of the combinator in the summary.
    */
   final UnlinkedCombinator _unlinkedCombinator;
@@ skipping 179 matching lines @@
     isSynthetic = true;
   }
 
   DartType get bound {
     if (_unlinkedTypeParam != null) {
       if (_unlinkedTypeParam.bound == null) {
         return null;
       }
       return _bound ??= enclosingUnit.resynthesizerContext.resolveTypeRef(
           _unlinkedTypeParam.bound, enclosingElement,
-          instantiateToBoundsAllowed: false);
+          instantiateToBoundsAllowed: false, declaredType: true);
     }
     return _bound;
   }
 
   void set bound(DartType bound) {
     _assertNotResynthesized(_unlinkedTypeParam);
     _bound = bound;
   }
 
   @override
@@ skipping 463 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }