Resynthesize class fields and accessors 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 491 matching lines @@
   /**
    * Set whether this class is abstract.
    */
   void set abstract(bool isAbstract) {
     _assertNotResynthesized(_unlinkedClass);
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   @override
   List<PropertyAccessorElement> get accessors {
-    if (_unlinkedClass != null && _accessors == null) {
-      _resynthesizeFieldsAndPropertyAccessors();
+    if (_accessors == null) {
+      if (_kernel != null || _unlinkedClass != null) {
+        _resynthesizeFieldsAndPropertyAccessors();
+      }
     }
     return _accessors ?? const <PropertyAccessorElement>[];
   }
 
   @override
   void set accessors(List<PropertyAccessorElement> accessors) {
     _assertNotResynthesized(_unlinkedClass);
     super.accessors = accessors;
   }
 
@@ skipping 119 matching lines @@
       }
     }
     return !nearestNonMixinClass.constructors.any(isSuperConstructorAccessible);
   }
 
   @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
 
   @override
   List<FieldElement> get fields {
-    if (_unlinkedClass != null && _fields == null) {
-      _resynthesizeFieldsAndPropertyAccessors();
+    if (_fields == null) {
+      if (_kernel != null || _unlinkedClass != null) {
+        _resynthesizeFieldsAndPropertyAccessors();
+      }
     }
     return _fields ?? const <FieldElement>[];
   }
 
   @override
   void set fields(List<FieldElement> fields) {
     _assertNotResynthesized(_unlinkedClass);
     super.fields = fields;
   }
 
@@ skipping 558 matching lines @@
     }).toList(growable: false);
   }
 
   /**
    * Resynthesize explicit fields and property accessors and fill [_fields] and
    * [_accessors] with explicit and implicit elements.
    */
   void _resynthesizeFieldsAndPropertyAccessors() {
     assert(_fields == null);
     assert(_accessors == null);
-    // Build explicit fields and implicit property accessors.
     var explicitFields = <FieldElement>[];
     var implicitAccessors = <PropertyAccessorElement>[];
-    for (UnlinkedVariable v in _unlinkedClass.fields) {
-      FieldElementImpl field =
-          new FieldElementImpl.forSerializedFactory(v, this);
-      explicitFields.add(field);
-      implicitAccessors.add(
-          new PropertyAccessorElementImpl_ImplicitGetter(field)
-            ..enclosingElement = this);
-      if (!field.isConst && !field.isFinal) {
-        implicitAccessors.add(
-            new PropertyAccessorElementImpl_ImplicitSetter(field)
-              ..enclosingElement = this);
-      }
-    }
-    // Build explicit property accessors and implicit fields.
     var explicitAccessors = <PropertyAccessorElement>[];
     var implicitFields = <String, FieldElementImpl>{};
-    for (UnlinkedExecutable e in _unlinkedClass.executables) {
-      if (e.kind == UnlinkedExecutableKind.getter ||
-          e.kind == UnlinkedExecutableKind.setter) {
-        PropertyAccessorElementImpl accessor =
-            new PropertyAccessorElementImpl.forSerialized(e, this);
-        explicitAccessors.add(accessor);
-        // Create or update the implicit field.
-        String fieldName = accessor.displayName;
-        FieldElementImpl field = implicitFields[fieldName];
-        if (field == null) {
-          field = new FieldElementImpl(fieldName, -1);
-          implicitFields[fieldName] = field;
-          field.enclosingElement = this;
-          field.isSynthetic = true;
-          field.isFinal = e.kind == UnlinkedExecutableKind.getter;
-          field.isStatic = e.isStatic;
-        } else {
-          field.isFinal = false;
+    if (_kernel != null) {
+      // Build explicit fields and implicit property accessors.
+      for (var k in _kernel.fields) {
+        var field = new FieldElementImpl.forKernelFactory(this, k);
+        explicitFields.add(field);
+        implicitAccessors.add(
+            new PropertyAccessorElementImpl_ImplicitGetter(field)
+              ..enclosingElement = this);
+        if (!field.isConst && !field.isFinal) {
+          implicitAccessors.add(
+              new PropertyAccessorElementImpl_ImplicitSetter(field)
+                ..enclosingElement = this);
         }
-        accessor.variable = field;
-        if (e.kind == UnlinkedExecutableKind.getter) {
-          field.getter = accessor;
-        } else {
-          field.setter = accessor;
+      }
+      // Build explicit property accessors and implicit fields.
+      for (var k in _kernel.procedures) {
+        bool isGetter = k.kind == kernel.ProcedureKind.Getter;
+        bool isSetter = k.kind == kernel.ProcedureKind.Setter;
+        if (isGetter || isSetter) {
+          var accessor = new PropertyAccessorElementImpl.forKernel(this, k);
+          explicitAccessors.add(accessor);
+          // Create or update the implicit field.
+          String fieldName = accessor.displayName;
+          FieldElementImpl field = implicitFields[fieldName];
+          if (field == null) {
+            field = new FieldElementImpl(fieldName, -1);
+            implicitFields[fieldName] = field;
+            field.enclosingElement = this;
+            field.isSynthetic = true;
+            field.isFinal = isGetter;
+            field.isStatic = k.isStatic;
+          } else {
+            field.isFinal = false;
+          }
+          accessor.variable = field;
+          if (isGetter) {
+            field.getter = accessor;
+          } else {
+            field.setter = accessor;
+          }
+        }
+      }
+    } else {
+      // Build explicit fields and implicit property accessors.
+      for (UnlinkedVariable v in _unlinkedClass.fields) {
+        FieldElementImpl field =
+            new FieldElementImpl.forSerializedFactory(v, this);
+        explicitFields.add(field);
+        implicitAccessors.add(
+            new PropertyAccessorElementImpl_ImplicitGetter(field)
+              ..enclosingElement = this);
+        if (!field.isConst && !field.isFinal) {
+          implicitAccessors.add(
+              new PropertyAccessorElementImpl_ImplicitSetter(field)
+                ..enclosingElement = this);
+        }
+      }
+      // Build explicit property accessors and implicit fields.
+      for (UnlinkedExecutable e in _unlinkedClass.executables) {
+        if (e.kind == UnlinkedExecutableKind.getter ||
+            e.kind == UnlinkedExecutableKind.setter) {
+          PropertyAccessorElementImpl accessor =
+              new PropertyAccessorElementImpl.forSerialized(e, this);
+          explicitAccessors.add(accessor);
+          // Create or update the implicit field.
+          String fieldName = accessor.displayName;
+          FieldElementImpl field = implicitFields[fieldName];
+          if (field == null) {
+            field = new FieldElementImpl(fieldName, -1);
+            implicitFields[fieldName] = field;
+            field.enclosingElement = this;
+            field.isSynthetic = true;
+            field.isFinal = e.kind == UnlinkedExecutableKind.getter;
+            field.isStatic = e.isStatic;
+          } else {
+            field.isFinal = false;
+          }
+          accessor.variable = field;
+          if (e.kind == UnlinkedExecutableKind.getter) {
+            field.getter = accessor;
+          } else {
+            field.setter = accessor;
+          }
         }
       }
     }
     // Combine explicit and implicit fields and property accessors.
     _fields = <FieldElement>[]
       ..addAll(explicitFields)
       ..addAll(implicitFields.values);
     _accessors = <PropertyAccessorElement>[]
       ..addAll(explicitAccessors)
       ..addAll(implicitAccessors);
@@ skipping 2973 matching lines @@
  */
 class FieldElementImpl extends PropertyInducingElementImpl
     implements FieldElement {
   /**
    * Initialize a newly created synthetic field element to have the given [name]
    * at the given [offset].
    */
   FieldElementImpl(String name, int offset) : super(name, offset);
 
   /**
+   * Initialize using the given serialized information.
+   */
+  FieldElementImpl.forKernel(ElementImpl enclosingElement, kernel.Field kernel)
+      : super.forKernel(enclosingElement, kernel);
+
+  /**
+   * Initialize using the given serialized information.
+   */
+  factory FieldElementImpl.forKernelFactory(
+      ClassElementImpl enclosingClass, kernel.Field kernel) {
+    // TODO(scheglov) add support for constants.
+    return new FieldElementImpl.forKernel(enclosingClass, kernel);
+  }
+
+  /**
    * Initialize a newly created field element to have the given [name].
    */
   FieldElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   FieldElementImpl.forSerialized(
       UnlinkedVariable unlinkedVariable, ElementImpl enclosingElement)
       : super.forSerialized(unlinkedVariable, enclosingElement);
@@ skipping 34 matching lines @@
     _assertNotResynthesized(_unlinkedVariable);
     setModifier(Modifier.COVARIANT, isCovariant);
   }
 
   @override
   bool get isEnumConstant =>
       enclosingElement != null && enclosingElement.isEnum && !isSynthetic;
 
   @override
   bool get isStatic {
+    if (_kernel != null) {
+      return _kernel.isStatic;
+    }
     if (_unlinkedVariable != null) {
       return _unlinkedVariable.isStatic;
     }
     return hasModifier(Modifier.STATIC);
   }
 
   /**
    * Set whether this field is static.
    */
   void set isStatic(bool isStatic) {
@@ skipping 3773 matching lines @@
     super.appendTo(buffer);
   }
 }
 
 /**
  * A concrete implementation of a [PropertyAccessorElement].
  */
 class PropertyAccessorElementImpl extends ExecutableElementImpl
     implements PropertyAccessorElement {
   /**
+   * The kernel of the element.
+   */
+  final kernel.Procedure _kernelProcedure;
+
+  /**
    * The variable associated with this accessor.
    */
   PropertyInducingElement variable;
 
   /**
    * Initialize a newly created property accessor element to have the given
    * [name] and [offset].
    */
-  PropertyAccessorElementImpl(String name, int offset) : super(name, offset);
+  PropertyAccessorElementImpl(String name, int offset)
+      : _kernelProcedure = null,
+        super(name, offset);
+
+  /**
+   * Initialize using the given kernel.
+   */
+  PropertyAccessorElementImpl.forKernel(
+      ElementImpl enclosingElement, this._kernelProcedure)
+      : super.forKernel(enclosingElement, _kernelProcedure);
 
   /**
    * Initialize a newly created property accessor element to have the given
    * [name].
    */
-  PropertyAccessorElementImpl.forNode(Identifier name) : super.forNode(name);
+  PropertyAccessorElementImpl.forNode(Identifier name)
+      : _kernelProcedure = null,
+        super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   PropertyAccessorElementImpl.forSerialized(
       UnlinkedExecutable serializedExecutable, ElementImpl enclosingElement)
-      : super.forSerialized(serializedExecutable, enclosingElement);
+      : _kernelProcedure = null,
+        super.forSerialized(serializedExecutable, enclosingElement);
 
   /**
    * Initialize a newly created synthetic property accessor element to be
    * associated with the given [variable].
    */
   PropertyAccessorElementImpl.forVariable(PropertyInducingElementImpl variable)
-      : super(variable.name, variable.nameOffset) {
+      : _kernelProcedure = null,
+        super(variable.name, variable.nameOffset) {
     this.variable = variable;
     isStatic = variable.isStatic;
     isSynthetic = true;
   }
 
   /**
    * Set whether this accessor is abstract.
    */
   void set abstract(bool isAbstract) {
     _assertNotResynthesized(serializedExecutable);
@@ skipping 49 matching lines @@
 
   @override
   String get identifier {
     String name = displayName;
     String suffix = isGetter ? "?" : "=";
     return "$name$suffix";
   }
 
   @override
   bool get isGetter {
+    if (_kernel != null) {
+      return _kernelProcedure.kind == kernel.ProcedureKind.Getter;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.kind == UnlinkedExecutableKind.getter;
     }
     return hasModifier(Modifier.GETTER);
   }
 
   @override
   bool get isSetter {
+    if (_kernel != null) {
+      return _kernelProcedure.kind == kernel.ProcedureKind.Setter;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.kind == UnlinkedExecutableKind.setter;
     }
     return hasModifier(Modifier.SETTER);
   }
 
   @override
   bool get isStatic {
+    if (_kernel != null) {
+      return _kernelProcedure.isStatic;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.isStatic ||
           variable is TopLevelVariableElement;
     }
     return hasModifier(Modifier.STATIC);
   }
 
   /**
    * Set whether this accessor is static.
    */
@@ skipping 1036 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }