Avoid writing to the same parts of the element model in two tasks.

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 3563 matching lines @@
    */
   List<ParameterElement> _parameters;
 
   /**
    * A list containing all of the type parameters defined for this executable
    * element.
    */
   List<TypeParameterElement> _typeParameters;
 
   /**
-   * The return type defined by this executable element.
+   * The declared return type of this executable element.
+   */
+  DartType _declaredReturnType;
+
+  /**
+   * The inferred return type of this executable element.
    */
   DartType _returnType;
 
   /**
    * The type of function defined by this executable element.
    */
   FunctionType _type;
 
   /**
    * Initialize a newly created executable element to have the given [name] and
@@ skipping 34 matching lines @@
   }
 
   @override
   int get codeOffset {
     if (serializedExecutable != null) {
       return serializedExecutable.codeRange?.offset;
     }
     return super.codeOffset;
   }
 
+  void set declaredReturnType(DartType returnType) {
+    _assertNotResynthesized(serializedExecutable);
+    _declaredReturnType = returnType;
+  }
+
   @override
   String get displayName {
     if (serializedExecutable != null) {
       return serializedExecutable.name;
     }
     return super.displayName;
   }
 
   @override
   String get documentationComment {
@@ skipping 191 matching lines @@
   void set parameters(List<ParameterElement> parameters) {
     _assertNotResynthesized(serializedExecutable);
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
 
   @override
   DartType get returnType {
-    if (serializedExecutable != null && _returnType == null) {
+    if (serializedExecutable != null &&
+        _declaredReturnType == null &&
+        _returnType == null) {
       bool isSetter =
           serializedExecutable.kind == UnlinkedExecutableKind.setter;
       _returnType = enclosingUnit.resynthesizerContext.resolveLinkedType(
-              serializedExecutable.inferredReturnTypeSlot,
-              typeParameterContext) ??
-          enclosingUnit.resynthesizerContext.resolveTypeRef(
-              serializedExecutable.returnType, typeParameterContext,
-              defaultVoid: isSetter && context.analysisOptions.strongMode);
+          serializedExecutable.inferredReturnTypeSlot, typeParameterContext);
+      _declaredReturnType = enclosingUnit.resynthesizerContext.resolveTypeRef(
+          serializedExecutable.returnType, typeParameterContext,
+          defaultVoid: isSetter && context.analysisOptions.strongMode);
     }
-    return _returnType;
+    return _returnType ?? _declaredReturnType;
   }
 
   void set returnType(DartType returnType) {
     _assertNotResynthesized(serializedExecutable);
     _returnType = returnType;
   }
 
   @override
   FunctionType get type {
     if (serializedExecutable != null) {
@@ skipping 2892 matching lines @@
   int get nameOffset {
     int offset = super.nameOffset;
     if (offset == 0 && _unlinkedVariable != null) {
       return _unlinkedVariable.nameOffset;
     }
     return offset;
   }
 
   @override
   DartType get type {
-    if (_unlinkedVariable != null && _type == null) {
+    if (_unlinkedVariable != null && _declaredType == null && _type == null) {
       _type = enclosingUnit.resynthesizerContext.resolveLinkedType(
-              _unlinkedVariable.inferredTypeSlot, typeParameterContext) ??
-          enclosingUnit.resynthesizerContext
-              .resolveTypeRef(_unlinkedVariable.type, typeParameterContext);
+          _unlinkedVariable.inferredTypeSlot, typeParameterContext);
+      _declaredType = enclosingUnit.resynthesizerContext
+          .resolveTypeRef(_unlinkedVariable.type, typeParameterContext);
     }
     return super.type;
   }
 
   void set type(DartType type) {
     _assertNotResynthesized(_unlinkedVariable);
     _type = type;
   }
 
   /**
@@ skipping 419 matching lines @@
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(parameters, visitor);
   }
 
   /**
    * If this element is resynthesized, and its type and parameters have not
    * been build yet, build them and remember in the corresponding fields.
    */
   void _resynthesizeTypeAndParameters() {
-    if (_unlinkedParam != null && _type == null) {
+    if (_unlinkedParam != null && _declaredType == null && _type == null) {
       if (_unlinkedParam.isFunctionTyped) {
         CompilationUnitElementImpl enclosingUnit = this.enclosingUnit;
         FunctionElementImpl parameterTypeElement =
             new FunctionElementImpl_forFunctionTypedParameter(
                 enclosingUnit, this);
         if (!isSynthetic) {
           parameterTypeElement.enclosingElement = this;
         }
         List<ParameterElement> subParameters = ParameterElementImpl
             .resynthesizeList(_unlinkedParam.parameters, this,
                 synthetic: isSynthetic);
         if (isSynthetic) {
           parameterTypeElement.parameters = subParameters;
         } else {
           _parameters = subParameters;
           parameterTypeElement.shareParameters(subParameters);
         }
         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) ??
-            enclosingUnit.resynthesizerContext
-                .resolveTypeRef(_unlinkedParam.type, typeParameterContext);
+            _unlinkedParam.inferredTypeSlot, typeParameterContext);
+        _declaredType = enclosingUnit.resynthesizerContext
+            .resolveTypeRef(_unlinkedParam.type, typeParameterContext);
       }
     }
   }
 
   /**
    * Create and return [ParameterElement]s for the given [unlinkedParameters].
    */
   static List<ParameterElement> resynthesizeList(
       List<UnlinkedParam> unlinkedParameters, ElementImpl enclosingElement,
       {bool synthetic: false}) {
@@ skipping 1038 matching lines @@
 }
 
 /**
  * A concrete implementation of a [VariableElement].
  */
 abstract class VariableElementImpl extends ElementImpl
     implements VariableElement {
   /**
    * The declared type of this variable.
    */
+  DartType _declaredType;
+
+  /**
+   * The inferred type of this variable.
+   */
   DartType _type;
 
   /**
    * A synthetic function representing this variable's initializer, or `null` if
    * this variable does not have an initializer.
    */
   FunctionElement _initializer;
 
   /**
    * Initialize a newly created variable element to have the given [name] and
@@ skipping 26 matching lines @@
    * Note that in correct Dart code, all constant variables must have
    * initializers.  However, analyzer also needs to handle incorrect Dart code,
    * in which case there might be some constant variables that lack
    * initializers.
    */
   Expression get constantInitializer => null;
 
   @override
   DartObject get constantValue => evaluationResult?.value;
 
+  void set declaredType(DartType type) {
+    _declaredType = type;
+  }
+
   @override
   String get displayName => name;
 
   /**
    * Return the result of evaluating this variable's initializer as a
    * compile-time constant expression, or `null` if this variable is not a
    * 'const' variable, if it does not have an initializer, or if the compilation
    * unit containing the variable has not been resolved.
    */
   EvaluationResultImpl get evaluationResult => null;
@@ skipping 53 matching lines @@
   @override
   bool get isPotentiallyMutatedInClosure => false;
 
   @override
   bool get isPotentiallyMutatedInScope => false;
 
   @override
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   @override
-  DartType get type => _type;
+  DartType get type => _type ?? _declaredType;
 
   void set type(DartType type) {
     _type = type;
   }
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(type);
     buffer.write(" ");
     buffer.write(displayName);
@@ skipping 19 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }