The very first bits of resynthesizing elements from kernels.

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 12 matching lines @@
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/task/dart.dart';
+import 'package:kernel/kernel.dart' as kernel;
 
 /**
  * Assert that the given [object] is null, which in the places where this
  * function is called means that the element is not resynthesized.
  */
 void _assertNotResynthesized(Object object) {
   // TODO(scheglov) I comment this check for now.
   // When we make a decision about switch to the new analysis driver,
   // we will need to rework the analysis code to don't call the setters
   // or restore / inline it.
@@ skipping 361 matching lines @@
  * An [AbstractClassElementImpl] which is a class.
  */
 class ClassElementImpl extends AbstractClassElementImpl
     with TypeParameterizedElementMixin {
   /**
    * The unlinked representation of the class in the summary.
    */
   final UnlinkedClass _unlinkedClass;
 
   /**
+   * The kernel of the element.
+   */
+  final kernel.Class _kernel;
+
+  /**
    * The superclass of the class, or `null` for [Object].
    */
   InterfaceType _supertype;
 
   /**
    * The type defined by the class.
    */
   InterfaceType _type;
 
   /**
@@ skipping 35 matching lines @@
    * methods might be different.
    */
   int version = 0;
 
   /**
    * Initialize a newly created class element to have the given [name] at the
    * given [offset] in the file that contains the declaration of this element.
    */
   ClassElementImpl(String name, int offset)
       : _unlinkedClass = null,
+        _kernel = null,
         super(name, offset);
 
   /**
    * Initialize a newly created class element to have the given [name].
    */
   ClassElementImpl.forNode(Identifier name)
       : _unlinkedClass = null,
+        _kernel = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   ClassElementImpl.forSerialized(
       this._unlinkedClass, CompilationUnitElementImpl enclosingUnit)
-      : super.forSerialized(enclosingUnit);
+      : _kernel = null,
+        super.forSerialized(enclosingUnit);
+
+  /**
+   * Initialize using the given kernel.
+   */
+  ClassElementImpl.forKernel(
+      CompilationUnitElementImpl enclosingUnit, this._kernel)
+      : _unlinkedClass = null,
+        super.forSerialized(enclosingUnit);
 
   /**
    * Set whether this class is abstract.
    */
   void set abstract(bool isAbstract) {
     _assertNotResynthesized(_unlinkedClass);
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   @override
@@ skipping 31 matching lines @@
       return _unlinkedClass.codeRange?.offset;
     }
     return super.codeOffset;
   }
 
   @override
   List<ConstructorElement> get constructors {
     if (isMixinApplication) {
       return _computeMixinAppConstructors();
     }
+    if (_kernel != null && _constructors == null) {
+      _constructors = _kernel.constructors
+          .map((k) => new ConstructorElementImpl.forKernel(this, k))
+          .toList(growable: false);
+    }
     if (_unlinkedClass != null && _constructors == null) {
       _constructors = _unlinkedClass.executables
           .where((e) => e.kind == UnlinkedExecutableKind.constructor)
           .map((e) => new ConstructorElementImpl.forSerialized(e, this))
           .toList(growable: false);
       // Ensure at least implicit default constructor.
       if (_constructors.isEmpty) {
         ConstructorElementImpl constructor = new ConstructorElementImpl('', -1);
         constructor.isSynthetic = true;
         constructor.enclosingElement = this;
@@ skipping 184 matching lines @@
     return _interfaces ?? const <InterfaceType>[];
   }
 
   void set interfaces(List<InterfaceType> interfaces) {
     _assertNotResynthesized(_unlinkedClass);
     _interfaces = interfaces;
   }
 
   @override
   bool get isAbstract {
+    if (_kernel != null) {
+      return _kernel.isAbstract;
+    }
     if (_unlinkedClass != null) {
       return _unlinkedClass.isAbstract;
     }
     return hasModifier(Modifier.ABSTRACT);
   }
 
   @override
   bool get isEnum => false;
 
   @override
@@ skipping 87 matching lines @@
     return _mixins ?? const <InterfaceType>[];
   }
 
   void set mixins(List<InterfaceType> mixins) {
     _assertNotResynthesized(_unlinkedClass);
     _mixins = mixins;
   }
 
   @override
   String get name {
+    if (_kernel != null) {
+      return _kernel.name;
+    }
     if (_unlinkedClass != null) {
       return _unlinkedClass.name;
     }
     return super.name;
   }
 
   @override
   int get nameOffset {
     int offset = super.nameOffset;
     if (offset == 0 && _unlinkedClass != null) {
@@ skipping 414 matching lines @@
    * The unlinked representation of the unit in the summary.
    */
   final UnlinkedUnit _unlinkedUnit;
 
   /**
    * The unlinked representation of the part in the summary.
    */
   final UnlinkedPart _unlinkedPart;
 
   /**
+   * The kernel context in which the library is resynthesized.
+   */
+  final KernelLibraryResynthesizerContext _kernelContext;
+
+  /**
    * The source that corresponds to this compilation unit.
    */
   @override
   Source source;
 
   @override
   LineInfo lineInfo;
 
   /**
    * The source of the library containing this compilation unit.
@@ skipping 63 matching lines @@
       _topLevelVariableReplaceMap;
 
   /**
    * Initialize a newly created compilation unit element to have the given
    * [name].
    */
   CompilationUnitElementImpl(String name)
       : resynthesizerContext = null,
         _unlinkedUnit = null,
         _unlinkedPart = null,
+        _kernelContext = null,
         super(name, -1);
 
   /**
    * Initialize using the given serialized information.
    */
   CompilationUnitElementImpl.forSerialized(
       LibraryElementImpl enclosingLibrary,
       this.resynthesizerContext,
       this._unlinkedUnit,
       this._unlinkedPart,
       String name)
-      : super.forSerialized(null) {
+      : _kernelContext = null,
+        super.forSerialized(null) {
     _enclosingElement = enclosingLibrary;
     _name = name;
     _nameOffset = -1;
+  }
+
+  /**
+   * Initialize using the given kernel information.
+   */
+  CompilationUnitElementImpl.forKernel(
+      LibraryElementImpl enclosingLibrary, this._kernelContext, String name)
+      : resynthesizerContext = null,
+        _unlinkedUnit = null,
+        _unlinkedPart = null,
+        super.forSerialized(null) {
+    _enclosingElement = enclosingLibrary;
+    _name = name;
+    _nameOffset = -1;
   }
 
   @override
   List<PropertyAccessorElement> get accessors {
     if (_unlinkedUnit != null) {
       if (_accessors == null) {
         _explicitTopLevelAccessors ??=
             resynthesizerContext.buildTopLevelAccessors();
         _explicitTopLevelVariables ??=
             resynthesizerContext.buildTopLevelVariables();
@@ skipping 180 matching lines @@
       (typeAlias as ElementImpl).enclosingElement = this;
     }
     this._typeAliases = typeAliases;
   }
 
   @override
   TypeParameterizedElementMixin get typeParameterContext => null;
 
   @override
   List<ClassElement> get types {
+    if (_kernelContext != null) {
+      _types ??= _kernelContext.library.classes
+          .map((k) => new ClassElementImpl.forKernel(this, k))
+          .toList(growable: false);
+    }
     if (_unlinkedUnit != null) {
       _types ??= _unlinkedUnit.classes
           .map((c) => new ClassElementImpl.forSerialized(c, this))
           .toList(growable: false);
     }
     return _types ?? const <ClassElement>[];
   }
 
   /**
    * Set the types contained in this compilation unit to the given [types].
@@ skipping 339 matching lines @@
    */
   ConstructorElement _redirectedConstructor;
 
   /**
    * The initializers for this constructor (used for evaluating constant
    * instance creation expressions).
    */
   List<ConstructorInitializer> _constantInitializers;
 
   /**
+   * The kernel of the element.
+   */
+  final kernel.Constructor _kernel;
+
+  /**
    * The offset of the `.` before this constructor name or `null` if not named.
    */
   int _periodOffset;
 
   /**
    * Return the offset of the character immediately following the last character
    * of this constructor's name, or `null` if not named.
    */
   int _nameEnd;
 
   /**
    * True if this constructor has been found by constant evaluation to be free
    * of redirect cycles, and is thus safe to evaluate.
    */
   bool _isCycleFree = false;
 
   /**
    * Initialize a newly created constructor element to have the given [name] and
    * [offset].
    */
-  ConstructorElementImpl(String name, int offset) : super(name, offset);
+  ConstructorElementImpl(String name, int offset)
+      : _kernel = null,
+        super(name, offset);
 
   /**
    * Initialize a newly created constructor element to have the given [name].
    */
-  ConstructorElementImpl.forNode(Identifier name) : super.forNode(name);
+  ConstructorElementImpl.forNode(Identifier name)
+      : _kernel = null,
+        super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   ConstructorElementImpl.forSerialized(
       UnlinkedExecutable serializedExecutable, ClassElementImpl enclosingClass)
-      : super.forSerialized(serializedExecutable, enclosingClass);
+      : _kernel = null,
+        super.forSerialized(serializedExecutable, enclosingClass);
+
+  /**
+   * Initialize using the given serialized information.
+   */
+  ConstructorElementImpl.forKernel(
+      ClassElementImpl enclosingClass, this._kernel)
+      : super.forSerialized(null, enclosingClass) {
+    isSynthetic = _kernel.isSyntheticDefault;
+  }
 
   /**
    * Return the constant initializers for this element, which will be empty if
    * there are no initializers, or `null` if there was an error in the source.
    */
   List<ConstructorInitializer> get constantInitializers {
     if (serializedExecutable != null && _constantInitializers == null) {
       _constantInitializers ??= serializedExecutable.constantInitializers
           .map((i) => _buildConstructorInitializer(i))
           .toList(growable: false);
@@ skipping 1562 matching lines @@
  */
 abstract class ExecutableElementImpl extends ElementImpl
     with TypeParameterizedElementMixin
     implements ExecutableElement {
   /**
    * The unlinked representation of the executable in the summary.
    */
   final UnlinkedExecutable serializedExecutable;
 
   /**
+   * The kernel of the element.
+   */
+  final kernel.Member _kernel;
+
+  /**
    * A list containing all of the functions defined within this executable
    * element.
    */
   List<FunctionElement> _functions;
 
   /**
    * A list containing all of the parameters defined by this executable element.
    */
   List<ParameterElement> _parameters;
 
@@ skipping 11 matching lines @@
    * The type of function defined by this executable element.
    */
   FunctionType _type;
 
   /**
    * Initialize a newly created executable element to have the given [name] and
    * [offset].
    */
   ExecutableElementImpl(String name, int offset)
       : serializedExecutable = null,
+        _kernel = null,
         super(name, offset);
 
   /**
    * Initialize a newly created executable element to have the given [name].
    */
   ExecutableElementImpl.forNode(Identifier name)
       : serializedExecutable = null,
+        _kernel = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   ExecutableElementImpl.forSerialized(
       this.serializedExecutable, ElementImpl enclosingElement)
-      : super.forSerialized(enclosingElement);
+      : _kernel = null,
+        super.forSerialized(enclosingElement);
+
+  /**
+   * Initialize using the given kernel.
+   */
+  ExecutableElementImpl.forKernel(ElementImpl enclosingElement, this._kernel)
+      : serializedExecutable = null,
+        super.forSerialized(enclosingElement);
 
   /**
    * Set whether this executable element's body is asynchronous.
    */
   void set asynchronous(bool isAsynchronous) {
     _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.ASYNCHRONOUS, isAsynchronous);
   }
 
   @override
@@ skipping 129 matching lines @@
   List<ElementAnnotation> get metadata {
     if (serializedExecutable != null) {
       return _metadata ??=
           _buildAnnotations(enclosingUnit, serializedExecutable.annotations);
     }
     return super.metadata;
   }
 
   @override
   String get name {
+    if (_kernel != null) {
+      return _kernel.name.name;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.name;
     }
     return super.name;
   }
 
   @override
   int get nameOffset {
     int offset = super.nameOffset;
     if (offset == 0 && serializedExecutable != null) {
@@ skipping 1768 matching lines @@
  * A concrete implementation of a [LibraryElement].
  */
 class LibraryElementImpl extends ElementImpl implements LibraryElement {
   /**
    * The analysis context in which this library is defined.
    */
   final AnalysisContext context;
 
   final LibraryResynthesizerContext resynthesizerContext;
 
+  /**
+   * The kernel context in which the library is resynthesized.
+   */
+  final KernelLibraryResynthesizerContext _kernelContext;
+
   final UnlinkedUnit _unlinkedDefiningUnit;
 
   /**
    * The compilation unit that defines this library.
    */
   CompilationUnitElement _definingCompilationUnit;
 
   /**
    * The entry point for this library, or `null` if this library does not have
    * an entry point.
@@ skipping 57 matching lines @@
    * The cached list of prefixes.
    */
   List<PrefixElement> _prefixes;
 
   /**
    * Initialize a newly created library element in the given [context] to have
    * the given [name] and [offset].
    */
   LibraryElementImpl(this.context, String name, int offset, this.nameLength)
       : resynthesizerContext = null,
+        _kernelContext = null,
         _unlinkedDefiningUnit = null,
         super(name, offset);
 
   /**
    * Initialize a newly created library element in the given [context] to have
    * the given [name].
    */
   LibraryElementImpl.forNode(this.context, LibraryIdentifier name)
       : nameLength = name != null ? name.length : 0,
         resynthesizerContext = null,
+        _kernelContext = null,
         _unlinkedDefiningUnit = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   LibraryElementImpl.forSerialized(this.context, String name, int offset,
       this.nameLength, this.resynthesizerContext, this._unlinkedDefiningUnit)
-      : super.forSerialized(null) {
+      : _kernelContext = null,
+        super.forSerialized(null) {
     _name = name;
     _nameOffset = offset;
     setResolutionCapability(
         LibraryResolutionCapability.resolvedTypeNames, true);
     setResolutionCapability(
         LibraryResolutionCapability.constantExpressions, true);
   }
 
+  /**
+   * Initialize using the given kernel information.
+   */
+  LibraryElementImpl.forKernel(this.context, this._kernelContext)
+      : resynthesizerContext = null,
+        _unlinkedDefiningUnit = null,
+        nameLength = _kernelContext.library.name?.length ?? 0,
+        super.forSerialized(null) {
+    _name = _kernelContext.library.name ?? '';
+    _nameOffset = _kernelContext.library.fileOffset;
+    setResolutionCapability(
+        LibraryResolutionCapability.resolvedTypeNames, true);
+    setResolutionCapability(
+        LibraryResolutionCapability.constantExpressions, true);
+
+    definingCompilationUnit = new CompilationUnitElementImpl.forKernel(
+        this, _kernelContext, '<no-name>');
+
+    // TODO(scheglov) how to support parts?
+  }
+
   @override
   int get codeLength {
     CompilationUnitElement unit = _definingCompilationUnit;
     if (unit is CompilationUnitElementImpl) {
       return unit.codeLength;
     }
     return null;
   }
 
   @override
@@ skipping 3215 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }
+
+/**
+ * The kernel context in which a library is resynthesized.
+ */
+abstract class KernelLibraryResynthesizerContext {
+  kernel.Library get library;
+}