Resynthesize parameters from Kernel.

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 3914 matching lines @@
   int get nameOffset {
     int offset = super.nameOffset;
     if (offset == 0 && serializedExecutable != null) {
       return serializedExecutable.nameOffset;
     }
     return offset;
   }
 
   @override
   List<ParameterElement> get parameters {
-    if (serializedExecutable != null) {
-      _parameters ??= ParameterElementImpl.resynthesizeList(
-          serializedExecutable.parameters, this);
+    if (_parameters == null) {
+      if (_kernel != null) {
+        _parameters =
+            ParameterElementImpl.forKernelFunction(this, _kernel.function);
+      }
+      if (serializedExecutable != null) {
+        _parameters = ParameterElementImpl.resynthesizeList(
+            serializedExecutable.parameters, this);
+      }
     }
     return _parameters ?? const <ParameterElement>[];
   }
 
   /**
    * Set the parameters defined by this executable element to the given
    * [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
     _assertNotResynthesized(serializedExecutable);
@@ skipping 3424 matching lines @@
  */
 class ParameterElementImpl extends VariableElementImpl
     with ParameterElementMixin
     implements ParameterElement {
   /**
    * The unlinked representation of the parameter in the summary.
    */
   final UnlinkedParam _unlinkedParam;
 
   /**
+   * The kernel of the element;
+   */
+  final kernel.VariableDeclaration _kernel;
+
+  /**
    * A list containing all of the parameters defined by this parameter element.
    * There will only be parameters if this parameter is a function typed
    * parameter.
    */
   List<ParameterElement> _parameters = ParameterElement.EMPTY_LIST;
 
   /**
    * A list containing all of the type parameters defined for this parameter
    * element. There will only be parameters if this parameter is a function
    * typed parameter.
@@ skipping 22 matching lines @@
   int _visibleRangeLength = -1;
 
   bool _inheritsCovariant = false;
 
   /**
    * Initialize a newly created parameter element to have the given [name] and
    * [nameOffset].
    */
   ParameterElementImpl(String name, int nameOffset)
       : _unlinkedParam = null,
+        _kernel = null,
         super(name, nameOffset);
 
   /**
+   * Initialize using the given kernel.
+   */
+  ParameterElementImpl.forKernel(
+      ElementImpl enclosingElement, this._kernel, this._parameterKind)
+      : _unlinkedParam = null,
+        super.forSerialized(enclosingElement);
+
+  /**
    * Initialize a newly created parameter element to have the given [name].
    */
   ParameterElementImpl.forNode(Identifier name)
       : _unlinkedParam = null,
+        _kernel = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   ParameterElementImpl.forSerialized(
       this._unlinkedParam, ElementImpl enclosingElement)
-      : super.forSerialized(enclosingElement);
+      : _kernel = null,
+        super.forSerialized(enclosingElement);
 
   /**
    * Initialize using the given serialized information.
    */
   factory ParameterElementImpl.forSerializedFactory(
       UnlinkedParam unlinkedParameter, ElementImpl enclosingElement,
       {bool synthetic: false}) {
     ParameterElementImpl element;
     if (unlinkedParameter.isInitializingFormal) {
       if (unlinkedParameter.kind == UnlinkedParamKind.required) {
@@ skipping 118 matching lines @@
    * Set the function representing this variable's initializer to the given
    * [function].
    */
   void set initializer(FunctionElement function) {
     _assertNotResynthesized(_unlinkedParam);
     super.initializer = function;
   }
 
   @override
   bool get isConst {
+    if (_kernel != null) {
+      return false;
+    }
     if (_unlinkedParam != null) {
       return false;
     }
     return super.isConst;
   }
 
   @override
   void set isConst(bool isConst) {
     _assertNotResynthesized(_unlinkedParam);
     super.isConst = isConst;
@@ skipping 25 matching lines @@
   /**
    * Set whether this variable parameter is explicitly marked as being covariant.
    */
   void set isExplicitlyCovariant(bool isCovariant) {
     _assertNotResynthesized(_unlinkedParam);
     setModifier(Modifier.COVARIANT, isCovariant);
   }
 
   @override
   bool get isFinal {
+    if (_kernel != null) {
+      return _kernel.isFinal;
+    }
     if (_unlinkedParam != null) {
       return _unlinkedParam.isFinal;
     }
     return super.isFinal;
   }
 
   @override
   void set isFinal(bool isFinal) {
     _assertNotResynthesized(_unlinkedParam);
     super.isFinal = isFinal;
@@ skipping 15 matching lines @@
   List<ElementAnnotation> get metadata {
     if (_unlinkedParam != null) {
       return _metadata ??=
           _buildAnnotations(enclosingUnit, _unlinkedParam.annotations);
     }
     return super.metadata;
   }
 
   @override
   String get name {
+    if (_kernel != null) {
+      return _kernel.name;
+    }
     if (_unlinkedParam != null) {
       return _unlinkedParam.name;
     }
     return super.name;
   }
 
   @override
   int get nameOffset {
     int offset = super.nameOffset;
     if (offset == 0 && _unlinkedParam != null) {
       if (isSynthetic ||
           (_unlinkedParam.name.isEmpty &&
               _unlinkedParam.kind != UnlinkedParamKind.named &&
               enclosingElement is GenericFunctionTypeElement)) {
         return -1;
       }
       return _unlinkedParam.nameOffset;
     }
     return offset;
   }
 
   @override
   ParameterKind get parameterKind {
-    if (_unlinkedParam != null && _parameterKind == null) {
+    if (_parameterKind == null && _unlinkedParam != null) {

[Paul Berry, 2017/07/17 16:56:32]

What's the purpose of swapping these?  Consider reverting this change.

       switch (_unlinkedParam.kind) {
         case UnlinkedParamKind.named:
           _parameterKind = ParameterKind.NAMED;
           break;
         case UnlinkedParamKind.positional:
           _parameterKind = ParameterKind.POSITIONAL;
           break;
         case UnlinkedParamKind.required:
           _parameterKind = ParameterKind.REQUIRED;
           break;
@@ skipping 19 matching lines @@
    */
   void set parameters(List<ParameterElement> parameters) {
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
 
   @override
   DartType get type {
+    if (_kernel != null) {
+      return _type ??= enclosingUnit._kernelContext.getType(this, _kernel.type);
+    }
     _resynthesizeTypeAndParameters();
     return super.type;
   }
 
   @override
   TopLevelInferenceError get typeInferenceError {
     if (_unlinkedParam != null) {
       return enclosingUnit.resynthesizerContext
           .getTypeInferenceError(_unlinkedParam.inferredTypeSlot);
     }
@@ skipping 121 matching lines @@
       } else {
         _type = enclosingUnit.resynthesizerContext
             .resolveLinkedType(this, _unlinkedParam.inferredTypeSlot);
         declaredType = enclosingUnit.resynthesizerContext
             .resolveTypeRef(this, _unlinkedParam.type, declaredType: true);
       }
     }
   }
 
   /**
+   * Create and return [ParameterElement]s for the given [function].
+   */
+  static List<ParameterElement> forKernelFunction(
+      ElementImpl enclosingElement, kernel.FunctionNode function) {
+    if (function.positionalParameters.isNotEmpty ||
+        function.namedParameters.isNotEmpty) {
+      var parameters = <ParameterElement>[];
+      for (int i = 0; i < function.positionalParameters.length; i++) {
+        parameters.add(new ParameterElementImpl.forKernel(
+            enclosingElement,
+            function.positionalParameters[i],
+            i < function.requiredParameterCount
+                ? ParameterKind.REQUIRED
+                : ParameterKind.POSITIONAL));
+      }
+      for (var k in function.namedParameters) {
+        parameters.add(new ParameterElementImpl.forKernel(
+            enclosingElement, k, ParameterKind.NAMED));
+      }
+      return parameters;
+    } else {
+      return const <ParameterElement>[];
+    }
+  }
+
+  /**
    * Create and return [ParameterElement]s for the given [unlinkedParameters].
    */
   static List<ParameterElement> resynthesizeList(
       List<UnlinkedParam> unlinkedParameters, ElementImpl enclosingElement,
       {bool synthetic: false}) {
     int length = unlinkedParameters.length;
     if (length != 0) {
       List<ParameterElement> parameters = new List<ParameterElement>(length);
       for (int i = 0; i < length; i++) {
         parameters[i] = new ParameterElementImpl.forSerializedFactory(
@@ skipping 1332 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }