Fix for resynthesizing default values referencing type parameters.

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/token.dart';
@@ skipping 281 matching lines @@
     }
     return hasLibrarySummary(uri);
   }
 }
 
 /**
  * Builder of [Expression]s from [UnlinkedConst]s.
  */
 class _ConstExprBuilder {
   final _UnitResynthesizer resynthesizer;
+  final Element context;
   final UnlinkedConst uc;
 
+  bool _typeParameterContextReady = false;
+  TypeParameterizedElementMixin _typeParameterContext;
+
   int intPtr = 0;
   int doublePtr = 0;
   int stringPtr = 0;
   int refPtr = 0;
   final List<Expression> stack = <Expression>[];
 
-  _ConstExprBuilder(this.resynthesizer, this.uc);
+  _ConstExprBuilder(this.resynthesizer, this.context, this.uc);
+
+  TypeParameterizedElementMixin get typeParameterContext {
+    if (!_typeParameterContextReady) {
+      for (Element e = context; e != null; e = e.enclosingElement) {
+        if (e is TypeParameterizedElementMixin) {
+          _typeParameterContext = e;
+          break;
+        }
+      }
+      _typeParameterContextReady = true;
+    }
+    return _typeParameterContext;
+  }
 
   Expression build() {
     if (!uc.isValidConst) {
       return AstFactory.identifier3(r'$$invalidConstExpr$$');
     }
     for (UnlinkedConstOperation operation in uc.operations) {
       switch (operation) {
         case UnlinkedConstOperation.pushNull:
           _push(AstFactory.nullLiteral());
           break;
@@ skipping 290 matching lines @@
     ConstructorElement constructorElement;
     if (info.element != null) {
       if (info.element is ConstructorElement) {
         constructorName = info.name;
       } else if (info.element is ClassElement) {
         constructorName = null;
       } else {
         throw new StateError('Unsupported element for invokeConstructor '
             '${info.element?.runtimeType}');
       }
-      InterfaceType definingType =
-          resynthesizer._createConstructorDefiningType(info, ref.typeArguments);
+      InterfaceType definingType = resynthesizer._createConstructorDefiningType(
+          typeParameterContext, info, ref.typeArguments);
       constructorElement =
           resynthesizer._createConstructorElement(definingType, info);
       typeNode = _buildTypeAst(definingType);
     } else {
       if (info.enclosing != null) {
         if (info.enclosing.enclosing != null) {
           PrefixedIdentifier typeName = AstFactory.identifier5(
               info.enclosing.enclosing.name, info.enclosing.name);
           typeName.prefix.staticElement = info.enclosing.enclosing.element;
           typeName.identifier.staticElement = info.enclosing.element;
@@ skipping 959 matching lines @@
     return typeArguments;
   }
 }
 
 class _ResynthesizerContext implements ResynthesizerContext {
   final _UnitResynthesizer _unitResynthesizer;
 
   _ResynthesizerContext(this._unitResynthesizer);
 
   @override
-  ElementAnnotationImpl buildAnnotation(UnlinkedConst uc) {
-    return _unitResynthesizer.buildAnnotation(uc);
+  ElementAnnotationImpl buildAnnotation(Element context, UnlinkedConst uc) {
+    return _unitResynthesizer.buildAnnotation(context, uc);
   }
 
   @override
-  Expression buildExpression(UnlinkedConst uc) {
-    return _unitResynthesizer._buildConstExpression(uc);
+  Expression buildExpression(Element context, UnlinkedConst uc) {
+    return _unitResynthesizer._buildConstExpression(context, uc);
   }
 
   @override
   UnitExplicitTopLevelAccessors buildTopLevelAccessors() {
     return _unitResynthesizer.buildUnitExplicitTopLevelAccessors();
   }
 
   @override
   UnitExplicitTopLevelVariables buildTopLevelVariables() {
     return _unitResynthesizer.buildUnitExplicitTopLevelVariables();
@@ skipping 128 matching lines @@
   }
 
   SummaryResynthesizer get summaryResynthesizer =>
       libraryResynthesizer.summaryResynthesizer;
 
   TypeProvider get typeProvider => summaryResynthesizer.typeProvider;
 
   /**
    * Build [ElementAnnotationImpl] for the given [UnlinkedConst].
    */
-  ElementAnnotationImpl buildAnnotation(UnlinkedConst uc) {
+  ElementAnnotationImpl buildAnnotation(Element context, UnlinkedConst uc) {
     ElementAnnotationImpl elementAnnotation = new ElementAnnotationImpl(unit);
-    Expression constExpr = _buildConstExpression(uc);
+    Expression constExpr = _buildConstExpression(context, uc);
     if (constExpr is Identifier) {
       elementAnnotation.element = constExpr.staticElement;
       elementAnnotation.annotationAst = AstFactory.annotation(constExpr);
     } else if (constExpr is InstanceCreationExpression) {
       elementAnnotation.element = constExpr.staticElement;
       Identifier typeName = constExpr.constructorName.type.name;
       SimpleIdentifier constructorName = constExpr.constructorName.name;
       if (typeName is SimpleIdentifier && constructorName != null) {
         // E.g. `@cls.ctor()`.  Since `cls.ctor` would have been parsed as
         // a PrefixedIdentifier, we need to resynthesize it as one.
         typeName = AstFactory.identifier(typeName, constructorName);
         constructorName = null;
       }
       elementAnnotation.annotationAst = AstFactory.annotation2(
           typeName, constructorName, constExpr.argumentList);
     } else {
       throw new StateError(
           'Unexpected annotation type: ${constExpr.runtimeType}');
     }
     return elementAnnotation;
   }
 
   /**
    * Build the annotations for the given [element].
    */
   void buildAnnotations(
       ElementImpl element, List<UnlinkedConst> serializedAnnotations) {
     if (serializedAnnotations.isNotEmpty) {
-      element.metadata = serializedAnnotations.map(buildAnnotation).toList();
+      element.metadata = serializedAnnotations
+          .map((a) => buildAnnotation(element, a))
+          .toList();
     }
   }
 
   /**
    * Resynthesize a [ClassElement] and place it in [unitHolder].
    */
   void buildClass(UnlinkedClass serializedClass) {
     ClassElement classElement;
     if (libraryResynthesizer.isCoreLibrary &&
         serializedClass.supertype == null) {
       classElement = buildClassImpl(serializedClass, null);
       if (!serializedClass.hasNoSupertype) {
         libraryResynthesizer.delayedObjectSubclasses.add(classElement);
       }
     } else {
       classElement = new _DeferredClassElement(this, unit, serializedClass);
     }
     unitHolder.addType(classElement);
   }
 
   /**
    * Fill the given [ClassElementImpl] with executable elements and fields.
    */
   void buildClassExecutables(
       ClassElementImpl classElement, UnlinkedClass serializedClass) {
     currentTypeParameters.add(classElement.typeParameters);
     ElementHolder memberHolder = new ElementHolder();
     fields = <String, FieldElementImpl>{};
     for (UnlinkedVariable serializedVariable in serializedClass.fields) {
-      buildVariable(serializedVariable, memberHolder);
+      buildVariable(classElement, serializedVariable, memberHolder);
     }
     bool constructorFound = false;
     constructors = <String, ConstructorElementImpl>{};
     for (UnlinkedExecutable serializedExecutable
         in serializedClass.executables) {
       switch (serializedExecutable.kind) {
         case UnlinkedExecutableKind.constructor:
           constructorFound = true;
           buildConstructor(serializedExecutable, classElement, memberHolder);
           break;
@@ skipping 90 matching lines @@
       HideElementCombinatorImpl combinator = new HideElementCombinatorImpl();
       // Note: we call toList() so that we don't retain a reference to the
       // deserialized data structure.
       combinator.hiddenNames = serializedCombinator.hides.toList();
       return combinator;
     }
   }
 
   /**
    * Resynthesize a [ConstructorElement] and place it in the given [holder].
-   * [classType] is the type of the class for which this element is a
+   * [classElement] is the element of the class for which this element is a
    * constructor.
    */
   void buildConstructor(UnlinkedExecutable serializedExecutable,
       ClassElementImpl classElement, ElementHolder holder) {
     assert(serializedExecutable.kind == UnlinkedExecutableKind.constructor);
     currentConstructor = new ConstructorElementImpl.forSerialized(
         serializedExecutable, classElement);
     currentConstructor.isCycleFree = serializedExecutable.isConst &&
         !constCycles.contains(serializedExecutable.constCycleSlot);
     if (serializedExecutable.name.isEmpty) {
       currentConstructor.nameEnd =
           serializedExecutable.nameOffset + classElement.name.length;
     } else {
       currentConstructor.nameEnd = serializedExecutable.nameEnd;
       currentConstructor.periodOffset = serializedExecutable.periodOffset;
     }
     constructors[serializedExecutable.name] = currentConstructor;
     currentConstructor.returnType = classElement.type;
     buildExecutableCommonParts(currentConstructor, serializedExecutable);
     currentConstructor.constantInitializers = serializedExecutable
         .constantInitializers
-        .map(buildConstructorInitializer)
+        .map((i) => buildConstructorInitializer(currentConstructor, i))
         .toList();
     if (serializedExecutable.isRedirectedConstructor) {
       if (serializedExecutable.isFactory) {
         EntityRef redirectedConstructor =
             serializedExecutable.redirectedConstructor;
         _ReferenceInfo info = getReferenceInfo(redirectedConstructor.reference);
         List<EntityRef> typeArguments = redirectedConstructor.typeArguments;
         currentConstructor.redirectedConstructor = _createConstructorElement(
-            _createConstructorDefiningType(info, typeArguments), info);
+            _createConstructorDefiningType(classElement, info, typeArguments),
+            info);
       } else {
         List<String> locationComponents = unit.location.components.toList();
         locationComponents.add(classElement.name);
         locationComponents.add(serializedExecutable.redirectedConstructorName);
         currentConstructor.redirectedConstructor =
             new _DeferredConstructorElement._(
                 classElement.type,
                 serializedExecutable.redirectedConstructorName,
                 new ElementLocationImpl.con3(locationComponents));
       }
     }
     holder.addConstructor(currentConstructor);
     currentConstructor = null;
   }
 
   /**
    * Resynthesize the [ConstructorInitializer] in context of
    * [currentConstructor], which is used to resolve constructor parameter names.
    */
   ConstructorInitializer buildConstructorInitializer(
+      ConstructorElementImpl enclosingConstructor,
       UnlinkedConstructorInitializer serialized) {
     UnlinkedConstructorInitializerKind kind = serialized.kind;
     String name = serialized.name;
     List<Expression> arguments = <Expression>[];
     {
       int numArguments = serialized.arguments.length;
       int numNames = serialized.argumentNames.length;
       for (int i = 0; i < numArguments; i++) {
-        Expression expression = _buildConstExpression(serialized.arguments[i]);
+        Expression expression = _buildConstExpression(
+            enclosingConstructor, serialized.arguments[i]);
         int nameIndex = numNames + i - numArguments;
         if (nameIndex >= 0) {
           expression = AstFactory.namedExpression2(
               serialized.argumentNames[nameIndex], expression);
         }
         arguments.add(expression);
       }
     }
     switch (kind) {
       case UnlinkedConstructorInitializerKind.field:
-        return AstFactory.constructorFieldInitializer(
-            false, name, _buildConstExpression(serialized.expression));
+        return AstFactory.constructorFieldInitializer(false, name,
+            _buildConstExpression(enclosingConstructor, serialized.expression));
       case UnlinkedConstructorInitializerKind.superInvocation:
         return AstFactory.superConstructorInvocation2(
             name.isNotEmpty ? name : null, arguments);
       case UnlinkedConstructorInitializerKind.thisInvocation:
         return AstFactory.redirectingConstructorInvocation2(
             name.isNotEmpty ? name : null, arguments);
     }
   }
 
   /**
@@ skipping 351 matching lines @@
    * Resynthesize a [LocalVariableElement].
    */
   LocalVariableElement buildLocalVariable(UnlinkedVariable serializedVariable,
       ExecutableElementImpl enclosingExecutable) {
     LocalVariableElementImpl element;
     if (serializedVariable.constExpr != null && serializedVariable.isConst) {
       ConstLocalVariableElementImpl constElement =
           new ConstLocalVariableElementImpl.forSerialized(
               serializedVariable, enclosingExecutable);
       element = constElement;
-      constElement.constantInitializer =
-          _buildConstExpression(serializedVariable.constExpr);
+      constElement.constantInitializer = _buildConstExpression(
+          enclosingExecutable, serializedVariable.constExpr);
     } else {
       element = new LocalVariableElementImpl.forSerialized(
           serializedVariable, enclosingExecutable);
     }
     if (serializedVariable.visibleOffset != 0) {
       element.setVisibleRange(
           serializedVariable.visibleOffset, serializedVariable.visibleLength);
     }
     buildVariableCommonParts(element, serializedVariable,
         isLazilyResynthesized: true);
@@ skipping 13 matching lines @@
       FieldFormalParameterElementImpl initializingParameter;
       if (serializedParameter.kind == UnlinkedParamKind.required) {
         initializingParameter = new FieldFormalParameterElementImpl(
             serializedParameter.name, nameOffset);
       } else {
         DefaultFieldFormalParameterElementImpl defaultParameter =
             new DefaultFieldFormalParameterElementImpl(
                 serializedParameter.name, nameOffset);
         initializingParameter = defaultParameter;
         if (serializedParameter.defaultValue != null) {
-          defaultParameter.constantInitializer =
-              _buildConstExpression(serializedParameter.defaultValue);
+          defaultParameter.constantInitializer = _buildConstExpression(
+              enclosingElement, serializedParameter.defaultValue);
           defaultParameter.defaultValueCode =
               serializedParameter.defaultValueCode;
         }
       }
       parameterElement = initializingParameter;
       initializingParameter.field = fields[serializedParameter.name];
     } else {
       if (serializedParameter.kind == UnlinkedParamKind.required) {
         parameterElement = new ParameterElementImpl.forSerialized(
             serializedParameter, enclosingElement);
@@ skipping 247 matching lines @@
     UnitExplicitTopLevelVariables variablesData =
         new UnitExplicitTopLevelVariables();
     for (UnlinkedVariable unlinkedVariable in unlinkedUnit.variables) {
       TopLevelVariableElementImpl element;
       if (unlinkedVariable.constExpr != null && unlinkedVariable.isConst) {
         ConstTopLevelVariableElementImpl constElement =
             new ConstTopLevelVariableElementImpl.forSerialized(
                 unlinkedVariable, unit);
         element = constElement;
         constElement.constantInitializer =
-            _buildConstExpression(unlinkedVariable.constExpr);
+            _buildConstExpression(null, unlinkedVariable.constExpr);
       } else {
         element = new TopLevelVariableElementImpl.forSerialized(
             unlinkedVariable, unit);
       }
       buildPropertyIntroducingElementCommonParts(element, unlinkedVariable,
           isLazilyResynthesized: true);
       variablesData.variables.add(element);
       // implicit accessors
       String name = element.name;
       DartType type = element.type;
       variablesData.implicitAccessors
           .add(buildImplicitGetter(element, name, type));
       if (!(element.isConst || element.isFinal)) {
         variablesData.implicitAccessors
             .add(buildImplicitSetter(element, name, type));
       }
     }
     return variablesData;
   }
 
   /**
    * Resynthesize a [TopLevelVariableElement] or [FieldElement].
    */
-  void buildVariable(UnlinkedVariable serializedVariable,
+  void buildVariable(
+      ClassElementImpl enclosingClass, UnlinkedVariable serializedVariable,
       [ElementHolder holder]) {
     if (holder == null) {
       throw new UnimplementedError('Must be lazy');
     } else {
       FieldElementImpl element;
       if (serializedVariable.constExpr != null &&
           (serializedVariable.isConst ||
               serializedVariable.isFinal && !serializedVariable.isStatic)) {
         ConstFieldElementImpl constElement = new ConstFieldElementImpl(
             serializedVariable.name, serializedVariable.nameOffset);
         element = constElement;
         constElement.constantInitializer =
-            _buildConstExpression(serializedVariable.constExpr);
+            _buildConstExpression(enclosingClass, serializedVariable.constExpr);
       } else {
         element = new FieldElementImpl(
             serializedVariable.name, serializedVariable.nameOffset);
       }
       buildPropertyIntroducingElementCommonParts(element, serializedVariable);
       element.static = serializedVariable.isStatic;
       holder.addField(element);
       buildImplicitAccessors(element, holder);
       fields[element.name] = element;
     }
@@ skipping 242 matching lines @@
         } else if (initializer is RedirectingConstructorInvocation) {
           SimpleIdentifier nameNode = initializer.constructorName;
           ConstructorElement element = constructors[nameNode?.name ?? ''];
           initializer.staticElement = element;
           nameNode?.staticElement = element;
         }
       }
     }
   }
 
-  Expression _buildConstExpression(UnlinkedConst uc) {
-    return new _ConstExprBuilder(this, uc).build();
+  Expression _buildConstExpression(Element context, UnlinkedConst uc) {
+    return new _ConstExprBuilder(this, context, uc).build();
   }
 
   /**
    * Return the defining type for a [ConstructorElement] by applying
    * [typeArgumentRefs] to the given linked [info].
    */
   InterfaceType _createConstructorDefiningType(
-      _ReferenceInfo info, List<EntityRef> typeArgumentRefs) {
+      TypeParameterizedElementMixin typeParameterContext,
+      _ReferenceInfo info,
+      List<EntityRef> typeArgumentRefs) {
     bool isClass = info.element is ClassElement;
     _ReferenceInfo classInfo = isClass ? info : info.enclosing;
     List<DartType> typeArguments = typeArgumentRefs
-        .map((t) => buildType(t, _currentTypeParameterizedElement))
+        .map((t) => buildType(t, typeParameterContext))
         .toList();
     return classInfo.buildType(true, typeArguments.length, (i) {
       if (i < typeArguments.length) {
         return typeArguments[i];
       } else {
         return DynamicTypeImpl.instance;
       }
     }, const <int>[]);
   }
 
@@ skipping 24 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }