Resynthesize methods 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 821 matching lines @@
   List<ElementAnnotation> get metadata {
     if (_unlinkedClass != null) {
       return _metadata ??=
           _buildAnnotations(enclosingUnit, _unlinkedClass.annotations);
     }
     return super.metadata;
   }
 
   @override
   List<MethodElement> get methods {
+    if (_kernel != null) {
+      _methods ??= _kernel.procedures
+          .where((k) =>
+              k.kind == kernel.ProcedureKind.Method ||
+              k.kind == kernel.ProcedureKind.Operator)
+          .map((k) => new MethodElementImpl.forKernel(this, k))
+          .toList(growable: false);
+    }
     if (_unlinkedClass != null) {
       _methods ??= _unlinkedClass.executables
           .where((e) => e.kind == UnlinkedExecutableKind.functionOrMethod)
           .map((e) => new MethodElementImpl.forSerialized(e, this))
           .toList(growable: false);
     }
     return _methods ?? const <MethodElement>[];
   }
 
   /**
@@ skipping 2979 matching lines @@
   /**
    * Set whether this executable element has an implicit return type.
    */
   void set hasImplicitReturnType(bool hasImplicitReturnType) {
     _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.IMPLICIT_TYPE, hasImplicitReturnType);
   }
 
   @override
   bool get isAbstract {
+    if (_kernel != null) {
+      return _kernel.isAbstract;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.isAbstract;
     }
     return hasModifier(Modifier.ABSTRACT);
   }
 
   @override
   bool get isAsynchronous {
+    if (_kernel != null) {
+      kernel.AsyncMarker marker = _kernel.function.asyncMarker;
+      return marker == kernel.AsyncMarker.Async ||
+          marker == kernel.AsyncMarker.AsyncStar;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.isAsynchronous;
     }
     return hasModifier(Modifier.ASYNCHRONOUS);
   }
 
   @override
   bool get isExternal {
     if (_kernel != null) {
       return _kernel.isExternal;
     }
     if (serializedExecutable != null) {
       return serializedExecutable.isExternal;
     }
     return hasModifier(Modifier.EXTERNAL);
   }
 
   @override
   bool get isGenerator {
+    if (_kernel != null) {
+      kernel.AsyncMarker marker = _kernel.function.asyncMarker;
+      return marker == kernel.AsyncMarker.AsyncStar ||
+          marker == kernel.AsyncMarker.SyncStar;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.isGenerator;
     }
     return hasModifier(Modifier.GENERATOR);
   }
 
   @override
   bool get isOperator => false;
 
   @override
@@ skipping 47 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 (_kernel != null) {
+      return _returnType ??= enclosingUnit._kernelContext
+          .getType(this, _kernel.function.returnType);
+    }
     if (serializedExecutable != null &&
         _declaredReturnType == null &&
         _returnType == null) {
       bool isSetter =
           serializedExecutable.kind == UnlinkedExecutableKind.setter;
       _returnType = enclosingUnit.resynthesizerContext
           .resolveLinkedType(this, serializedExecutable.inferredReturnTypeSlot);
       _declaredReturnType = enclosingUnit.resynthesizerContext.resolveTypeRef(
           this, serializedExecutable.returnType,
           defaultVoid: isSetter && context.analysisOptions.strongMode,
@@ skipping 2597 matching lines @@
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
 }
 
 /**
  * A concrete implementation of a [MethodElement].
  */
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   /**
+   * The kernel of the element.
+   */
+  kernel.Procedure _kernelProcedure;
+
+  /**
    * Initialize a newly created method element to have the given [name] at the
    * given [offset].
    */
   MethodElementImpl(String name, int offset) : super(name, offset);
 
   /**
+   * Initialize using the given kernel.
+   */
+  MethodElementImpl.forKernel(
+      ClassElementImpl enclosingClass, this._kernelProcedure)
+      : super.forKernel(enclosingClass, _kernelProcedure);
+
+  /**
    * Initialize a newly created method element to have the given [name].
    */
   MethodElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   MethodElementImpl.forSerialized(
       UnlinkedExecutable serializedExecutable, ClassElementImpl enclosingClass)
       : super.forSerialized(serializedExecutable, enclosingClass);
@@ skipping 38 matching lines @@
     }
     int first = name.codeUnitAt(0);
     return !((0x61 <= first && first <= 0x7A) ||
         (0x41 <= first && first <= 0x5A) ||
         first == 0x5F ||
         first == 0x24);
   }
 
   @override
   bool get isStatic {
+    if (_kernel != null) {
+      return _kernelProcedure.isStatic;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.isStatic;
     }
     return hasModifier(Modifier.STATIC);
   }
 
   /**
    * Set whether this method is static.
    */
   void set isStatic(bool isStatic) {
@@ skipping 2537 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }