Resynthesize constructor initializers.

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/element/element.dart';
@@ skipping 417 matching lines @@
           _pushInstanceCreation();
           break;
         case UnlinkedConstOperation.length:
           Expression target = _pop();
           SimpleIdentifier property = AstFactory.identifier3('length');
           property.staticElement =
               resynthesizer._buildStringLengthPropertyAccessorElement();
           _push(AstFactory.propertyAccess(target, property));
           break;
         case UnlinkedConstOperation.pushConstructorParameter:
-          // TODO(scheglov) implement
-          throw new UnimplementedError('$operation');
+          String name = uc.strings[stringPtr++];
+          SimpleIdentifier identifier = AstFactory.identifier3(name);
+          identifier.staticElement = resynthesizer.currentConstructor.parameters
+              .firstWhere((parameter) => parameter.name == name,
+                  orElse: () => throw new StateError(
+                      'Unable to resolve constructor parameter: $name'));
+          _push(identifier);
           break;
       }
     }
     return stack.single;
   }
 
   TypeName _buildTypeAst(DartType type) {
     if (type is DynamicTypeImpl) {
       TypeName node = AstFactory.typeName4('dynamic');
       node.type = type;
@@ skipping 236 matching lines @@
    */
   Map<int, EntityRef> linkedTypeMap;
 
   /**
    * The [CompilationUnitElementImpl] for the compilation unit currently being
    * resynthesized.
    */
   CompilationUnitElementImpl currentCompilationUnit;
 
   /**
+   * The [ConstructorElementImpl] for the constructor currently being
+   * resynthesized.
+   */
+  ConstructorElementImpl currentConstructor;
+
+  /**
    * Map of top level elements that have been resynthesized so far.  The first
    * key is the URI of the compilation unit; the second is the name of the top
    * level element.
    */
   final Map<String, Map<String, Element>> resummarizedElements =
       <String, Map<String, Element>>{};
 
   /**
    * Type parameters for the generic class, typedef, or executable currently
    * being resynthesized, if any.  If multiple entities with type parameters
    * are nested (e.g. a generic executable inside a generic class), this is the
    * concatenation of all type parameters from all declarations currently in
    * force, with the outermost declaration appearing first.  If there are no
    * type parameters, or we are not currently resynthesizing a class, typedef,
    * or executable, then this is an empty list.
    */
   List<TypeParameterElement> currentTypeParameters = <TypeParameterElement>[];
 
   /**
    * If a class is currently being resynthesized, map from field name to the
    * corresponding field element.  This is used when resynthesizing
    * initializing formal parameters.
    */
   Map<String, FieldElementImpl> fields;
 
   /**
+   * If a class is currently being resynthesized, map from constructor name to
+   * the corresponding constructor element.  This is used when resynthesizing
+   * constructor initializers.
+   */
+  Map<String, ConstructorElementImpl> constructors;
+
+  /**
    * List of [_ReferenceInfo] objects describing the references in the current
    * compilation unit.
    */
   List<_ReferenceInfo> referenceInfos;
 
   _LibraryResynthesizer(this.summaryResynthesizer, this.linkedLibrary,
       this.unlinkedUnits, this.librarySource) {
     isCoreLibrary = librarySource.uri.toString() == 'dart:core';
   }
 
@@ skipping 66 matching lines @@
       classElement.interfaces =
           serializedClass.interfaces.map(buildType).toList();
       classElement.mixins = serializedClass.mixins.map(buildType).toList();
       classElement.typeParameters = currentTypeParameters;
       ElementHolder memberHolder = new ElementHolder();
       fields = <String, FieldElementImpl>{};
       for (UnlinkedVariable serializedVariable in serializedClass.fields) {
         buildVariable(serializedVariable, memberHolder);
       }
       bool constructorFound = false;
+      constructors = <String, ConstructorElementImpl>{};
       for (UnlinkedExecutable serializedExecutable
           in serializedClass.executables) {
         switch (serializedExecutable.kind) {
           case UnlinkedExecutableKind.constructor:
             constructorFound = true;
             buildConstructor(
                 serializedExecutable, memberHolder, correspondingType);
             break;
           case UnlinkedExecutableKind.functionOrMethod:
           case UnlinkedExecutableKind.getter:
           case UnlinkedExecutableKind.setter:
             buildExecutable(serializedExecutable, memberHolder);
             break;
         }
       }
       if (!serializedClass.isMixinApplication) {
         if (!constructorFound) {
           // Synthesize implicit constructors.
           ConstructorElementImpl constructor =
               new ConstructorElementImpl('', -1);
           constructor.synthetic = true;
           constructor.returnType = correspondingType;
           constructor.type = new FunctionTypeImpl.elementWithNameAndArgs(
               constructor, null, currentTypeArguments, false);
+//          constructor.constantInitializers = <ConstructorInitializer>[];

[Paul Berry, 2016/02/08 20:40:55]

Accidental debug code?

           memberHolder.addConstructor(constructor);
         }
         classElement.constructors = memberHolder.constructors;
       }
       classElement.accessors = memberHolder.accessors;
       classElement.fields = memberHolder.fields;
       classElement.methods = memberHolder.methods;
       correspondingType.typeArguments = currentTypeArguments;
       classElement.type = correspondingType;
       buildDocumentation(classElement, serializedClass.documentationComment);
       buildAnnotations(classElement, serializedClass.annotations);
+      resolveConstructorInitializers(classElement);
       unitHolder.addType(classElement);
     } finally {
       currentTypeParameters = <TypeParameterElement>[];
       fields = null;
+      constructors = null;
     }
   }
 
   /**
    * Resynthesize a [NamespaceCombinator].
    */
   NamespaceCombinator buildCombinator(UnlinkedCombinator serializedCombinator) {
     if (serializedCombinator.shows.isNotEmpty) {
       ShowElementCombinatorImpl combinator = new ShowElementCombinatorImpl();
       // Note: we call toList() so that we don't retain a reference to the
       // deserialized data structure.
       combinator.shownNames = serializedCombinator.shows.toList();
       return combinator;
     } else {
       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 the [ConstructorInitializer] in context of
+   * [currentConstructor], which is used to resolve constructor parameter names.
+   */
+  ConstructorInitializer buildConstantInitializer(
+      UnlinkedConstructorInitializer serialized) {
+    UnlinkedConstructorInitializerKind kind = serialized.kind;
+    String name = serialized.name;
+    List<Expression> arguments =
+        serialized.arguments.map(_buildConstExpression).toList();
+    switch (kind) {
+      case UnlinkedConstructorInitializerKind.field:
+        return AstFactory.constructorFieldInitializer(
+            false, name, _buildConstExpression(serialized.expression));
+      case UnlinkedConstructorInitializerKind.superInvocation:
+        return AstFactory.superConstructorInvocation2(
+            name.isNotEmpty ? name : null, arguments);
+      case UnlinkedConstructorInitializerKind.thisInvocation:
+        return AstFactory.redirectingConstructorInvocation2(
+            name.isNotEmpty ? name : null, arguments);
+    }
+  }
+
+  /**
    * Resynthesize a [ConstructorElement] and place it in the given [holder].
    * [classType] is the type of the class for which this element is a
    * constructor.
    */
   void buildConstructor(UnlinkedExecutable serializedExecutable,
       ElementHolder holder, InterfaceType classType) {
     assert(serializedExecutable.kind == UnlinkedExecutableKind.constructor);
-    ConstructorElementImpl constructorElement = new ConstructorElementImpl(
+    currentConstructor = new ConstructorElementImpl(
         serializedExecutable.name, serializedExecutable.nameOffset);
-    constructorElement.returnType = classType;
-    buildExecutableCommonParts(constructorElement, serializedExecutable);
-    constructorElement.factory = serializedExecutable.isFactory;
-    constructorElement.const2 = serializedExecutable.isConst;
-    holder.addConstructor(constructorElement);
+    constructors[serializedExecutable.name] = currentConstructor;
+    currentConstructor.returnType = classType;
+    buildExecutableCommonParts(currentConstructor, serializedExecutable);
+    currentConstructor.factory = serializedExecutable.isFactory;
+    currentConstructor.const2 = serializedExecutable.isConst;
+    currentConstructor.constantInitializers = serializedExecutable
+        .constantInitializers
+        .map(buildConstantInitializer)
+        .toList();
+    holder.addConstructor(currentConstructor);
+    currentConstructor = null;
   }
 
   /**
    * Build the documentation for the given [element].  Does nothing if
    * [serializedDocumentationComment] is `null`.
    */
   void buildDocumentation(ElementImpl element,
       UnlinkedDocumentationComment serializedDocumentationComment) {
     if (serializedDocumentationComment != null) {
       element.documentationComment = serializedDocumentationComment.text;
@@ skipping 888 matching lines @@
     unlinkedUnit = unlinkedUnits[unitNum];
     linkedTypeMap = <int, EntityRef>{};
     currentCompilationUnit = unit;
     for (EntityRef t in linkedUnit.types) {
       linkedTypeMap[t.slot] = t;
     }
     populateReferenceInfos();
     unitHolder = new ElementHolder();
   }
 
+  /**
+   * Constructor initializers can reference fields and other constructors of
+   * the same class, including forward references. So, we need to delay
+   * resolution until after class elements are built.
+   */
+  void resolveConstructorInitializers(ClassElementImpl classElement) {
+    for (ConstructorElementImpl constructor in constructors.values) {
+      for (ConstructorInitializer initializer
+          in constructor.constantInitializers) {
+        if (initializer is ConstructorFieldInitializer) {
+          SimpleIdentifier nameNode = initializer.fieldName;
+          nameNode.staticElement = fields[nameNode.name];
+        } else if (initializer is SuperConstructorInvocation) {
+          SimpleIdentifier nameNode = initializer.constructorName;
+          ConstructorElement element = new _DeferredConstructorElement(
+              classElement.supertype, nameNode?.name ?? '');
+          initializer.staticElement = element;
+          nameNode?.staticElement = element;
+        } 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();
   }
 
   /**
    * Return the new handle of the `String.length` getter element.
    */
   PropertyAccessorElementHandle _buildStringLengthPropertyAccessorElement() =>
       new PropertyAccessorElementHandle(
           summaryResynthesizer,
@@ skipping 134 matching lines @@
                 }
               : () => this.element;
       // TODO(paulberry): Is it a bug that we have to pass `false` for
       // isInstantiated?
       return new DeferredFunctionTypeImpl(computer, null, typeArguments, false);
     } else {
       return null;
     }
   }
 }