Resynthesize constructor properties.

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 458 matching lines @@
   /**
    * 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 using the given kernel.
+   */
+  ClassElementImpl.forKernel(
+      CompilationUnitElementImpl enclosingUnit, this._kernel)
+      : _unlinkedClass = null,
+        super.forSerialized(enclosingUnit);
+
+  /**
    * 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)
       : _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
   List<PropertyAccessorElement> get accessors {
     if (_unlinkedClass != null && _accessors == null) {
@@ skipping 877 matching lines @@
    * [name].
    */
   CompilationUnitElementImpl(String name)
       : resynthesizerContext = null,
         _unlinkedUnit = null,
         _unlinkedPart = null,
         _kernelContext = null,
         super(name, -1);
 
   /**
-   * Initialize using the given serialized information.
+   * Initialize using the given kernel information.
    */
-  CompilationUnitElementImpl.forSerialized(
-      LibraryElementImpl enclosingLibrary,
-      this.resynthesizerContext,
-      this._unlinkedUnit,
-      this._unlinkedPart,
-      String name)
-      : _kernelContext = null,
+  CompilationUnitElementImpl.forKernel(
+      LibraryElementImpl enclosingLibrary, this._kernelContext, String name)
+      : resynthesizerContext = null,
+        _unlinkedUnit = null,
+        _unlinkedPart = null,
         super.forSerialized(null) {
     _enclosingElement = enclosingLibrary;
     _name = name;
     _nameOffset = -1;
   }
 
   /**
-   * Initialize using the given kernel information.
+   * Initialize using the given serialized information.
    */
-  CompilationUnitElementImpl.forKernel(
-      LibraryElementImpl enclosingLibrary, this._kernelContext, String name)
-      : resynthesizerContext = null,
-        _unlinkedUnit = null,
-        _unlinkedPart = null,
+  CompilationUnitElementImpl.forSerialized(
+      LibraryElementImpl enclosingLibrary,
+      this.resynthesizerContext,
+      this._unlinkedUnit,
+      this._unlinkedPart,
+      String name)
+      : _kernelContext = null,
         super.forSerialized(null) {
     _enclosingElement = enclosingLibrary;
     _name = name;
     _nameOffset = -1;
   }
 
   @override
   List<PropertyAccessorElement> get accessors {
     if (_unlinkedUnit != null) {
       if (_accessors == null) {
@@ skipping 578 matching lines @@
 
   /**
    * Initialize a newly created constructor element to have the given [name] and
    * [offset].
    */
   ConstructorElementImpl(String name, int offset)
       : _kernel = null,
         super(name, offset);
 
   /**
+   * Initialize using the given serialized information.
+   */
+  ConstructorElementImpl.forKernel(
+      ClassElementImpl enclosingClass, this._kernel)
+      : super.forKernel(enclosingClass, _kernel) {
+    isSynthetic = _kernel.isSyntheticDefault;
+  }
+
+  /**
    * Initialize a newly created constructor element to have the given [name].
    */
   ConstructorElementImpl.forNode(Identifier name)
       : _kernel = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   ConstructorElementImpl.forSerialized(
       UnlinkedExecutable serializedExecutable, ClassElementImpl 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);
     }
     return _constantInitializers;
@@ skipping 16 matching lines @@
   /**
    * Set whether this constructor represents a factory method.
    */
   void set factory(bool isFactory) {
     _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.FACTORY, isFactory);
   }
 
   @override
   bool get isConst {
+    if (_kernel != null) {
+      return _kernel.isConst;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.isConst;
     }
     return hasModifier(Modifier.CONST);
   }
 
   /**
    * Set whether this constructor represents a 'const' constructor.
    */
   void set isConst(bool isConst) {
@@ skipping 1564 matching lines @@
   /**
    * 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 using the given kernel.
+   */
+  ExecutableElementImpl.forKernel(ElementImpl enclosingElement, this._kernel)
+      : serializedExecutable = null,
+        super.forSerialized(enclosingElement);
+
+  /**
    * 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)
       : _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
   int get codeLength {
     if (serializedExecutable != null) {
@@ skipping 10 matching lines @@
     return super.codeOffset;
   }
 
   void set declaredReturnType(DartType returnType) {
     _assertNotResynthesized(serializedExecutable);
     _declaredReturnType = _checkElementOfType(returnType);
   }
 
   @override
   String get displayName {
+    if (_kernel != null) {
+      return _kernel.name.name;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.name;
     }
     return super.displayName;
   }
 
   @override
   String get documentationComment {
     if (serializedExecutable != null) {
       return serializedExecutable?.documentationComment?.text;
@@ skipping 66 matching lines @@
   @override
   bool get isAsynchronous {
     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 (serializedExecutable != null) {
       return serializedExecutable.isGenerator;
@@ skipping 1729 matching lines @@
             : new HideElementCombinatorImpl.forSerialized(unlinkedCombinator);
       }
       return combinators;
     } else {
       return const <NamespaceCombinator>[];
     }
   }
 }
 
 /**
+ * The kernel context in which a library is resynthesized.
+ */
+abstract class KernelLibraryResynthesizerContext {
+  kernel.Library get library;
+}
+
+/**
  * A concrete implementation of a [LabelElement].
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
   /**
    * A flag indicating whether this label is associated with a `switch`
    * statement.
    */
   // TODO(brianwilkerson) Make this a modifier.
   final bool _onSwitchStatement;
 
@@ skipping 140 matching lines @@
    * 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 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?
+  }
+
+  /**
    * 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)
       : _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;
-}