Augment. Basic support for enum elements..

Change-Id: I42e7b58f7edaa979740a8e5b6787665c7a79c54d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/363500
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analysis_server/test/lsp/code_lens/augmentations_test.dart

@@ -198,7 +198,6 @@ augment class A {
     await expectNavigationCodeLens();
   }
 
-  @failingTest // "augment enum" is currently an error?
   test_available_enum() async {
     setLibraryContent(r'''
 enum [!A!] {

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -95,7 +95,7 @@ import 'package:meta/meta.dart';
 // TODO(scheglov): Clean up the list of implicitly analyzed files.
 class AnalysisDriver {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 355;
+  static const int DATA_VERSION = 356;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.

pkg/analyzer/lib/src/summary2/bundle_reader.dart

@@ -351,6 +351,20 @@ class EnumElementLinkedData extends ElementLinkedData<EnumElementImpl> {
     element.supertype = reader._readOptionalInterfaceType();
     element.mixins = reader._readInterfaceTypeList();
     element.interfaces = reader._readInterfaceTypeList();
+    element.augmentationTarget = reader.readElement() as EnumElementImpl?;
+    element.augmentation = reader.readElement() as EnumElementImpl?;
+    if (element.augmentationTarget == null) {
+      if (reader.readBool()) {
+        var augmented = AugmentedEnumElementImpl(element);
+        element.augmentedInternal = augmented;
+        augmented.mixins = reader._readInterfaceTypeList();
+        augmented.interfaces = reader._readInterfaceTypeList();
+        augmented.fields = reader.readElementList();
+        augmented.constructors = reader.readElementList();
+        augmented.accessors = reader.readElementList();
+        augmented.methods = reader.readElementList();
+      }
+    }
     applyConstantOffsets?.perform();
   }
 }

pkg/analyzer/lib/src/summary2/bundle_writer.dart

@@ -280,6 +280,21 @@ class BundleWriter {
       _resolutionSink.writeType(element.supertype);
       _resolutionSink._writeTypeList(element.mixins);
       _resolutionSink._writeTypeList(element.interfaces);
+      _resolutionSink.writeElement(element.augmentationTarget);
+      _resolutionSink.writeElement(element.augmentation);
+      if (element.augmentationTarget == null) {
+        _resolutionSink.writeIfType<AugmentedEnumElementImpl>(
+          element.augmented,
+          (augmented) {
+            _resolutionSink._writeTypeList(augmented.mixins);
+            _resolutionSink._writeTypeList(augmented.interfaces);
+            _resolutionSink._writeElementList(augmented.fields);
+            _resolutionSink._writeElementList(augmented.constructors);
+            _resolutionSink._writeElementList(augmented.accessors);
+            _resolutionSink._writeElementList(augmented.methods);
+          },
+        );
+      }
 
       _writeList(
         element.fields.where((e) {

pkg/analyzer/lib/src/summary2/element_builder.dart

@@ -239,6 +239,7 @@ class ElementBuilder extends ThrowingAstVisitor<void> {
     var nameOffset = nameNode.offset;
 
     var element = EnumElementImpl(name, nameOffset);
+    element.isAugmentation = node.augmentKeyword != null;
     element.metadata = _buildAnnotations(node.metadata);
     _setCodeRange(element, node);
     _setDocumentation(element, node);
@@ -249,6 +250,13 @@ class ElementBuilder extends ThrowingAstVisitor<void> {
     var reference = _enclosingContext.addEnum(name, element);
     _libraryBuilder.declare(name, reference);
 
+    _libraryBuilder.updateAugmentationTarget(name, element, (target) {
+      if (element.isAugmentation) {
+        target.augmentation = element;
+        element.augmentationTarget = target;
+      }
+    });
+
     var holder = _EnclosingContext(
       reference,
       element,
@@ -330,10 +338,8 @@ class ElementBuilder extends ThrowingAstVisitor<void> {
     }
 
     // Build the 'values' field.
-    ConstFieldElementImpl valuesField;
-    NamedTypeImpl valuesTypeNode;
-    {
-      valuesField = ConstFieldElementImpl('values', -1)
+    if (element.augmentationTarget == null) {
+      var valuesField = ConstFieldElementImpl('values', -1)
         ..isConst = true
         ..isStatic = true
         ..isSynthetic = true;
@@ -351,7 +357,7 @@ class ElementBuilder extends ThrowingAstVisitor<void> {
         equals: Tokens.eq(),
         initializer: initializer,
       );
-      valuesTypeNode = NamedTypeImpl(
+      var valuesTypeNode = NamedTypeImpl(
         importPrefix: null,
         name2: StringToken(TokenType.STRING, 'List', -1),
         typeArguments: TypeArgumentListImpl(
@@ -379,6 +385,14 @@ class ElementBuilder extends ThrowingAstVisitor<void> {
       _linker.elementNodes[valuesField] = variableDeclaration;
 
       holder.addNonSyntheticField(valuesField);
+
+      _libraryBuilder.implicitEnumNodes.add(
+        ImplicitEnumNodes(
+          element: element,
+          valuesTypeNode: valuesTypeNode,
+          valuesField: valuesField,
+        ),
+      );
     }
 
     node.withClause?.accept(this);
@@ -389,35 +403,25 @@ class ElementBuilder extends ThrowingAstVisitor<void> {
       _visitPropertyFirst<FieldDeclaration>(node.members);
     });
 
-    var needsImplicitConstructor = !holder.constructors.any(
-      (e) => e.name.isEmpty || e.isGenerative,
-    );
-
-    if (needsImplicitConstructor) {
-      holder.addConstructor(
-        ConstructorElementImpl('', -1)
-          ..isConst = true
-          ..isSynthetic = true,
-      );
-    }
-
-    _libraryBuilder.implicitEnumNodes.add(
-      ImplicitEnumNodes(
-        element: element,
-        valuesTypeNode: valuesTypeNode,
-        valuesField: valuesField,
-      ),
-    );
-
     element.accessors = holder.propertyAccessors;
     element.constructors = holder.constructors;
     element.fields = holder.fields;
     element.methods = holder.methods;
     element.typeParameters = holder.typeParameters;
 
-    // TODO(scheglov): We cannot do this anymore.
-    // Not for class augmentations, not for classes.
-    _resolveConstructorFieldFormals(element);
+    if (element.augmentationTarget != null) {
+      var builder = _libraryBuilder.getAugmentedBuilder(name);
+      if (builder is AugmentedEnumDeclarationBuilder) {
+        builder.augment(element);
+      }
+    } else {
+      _libraryBuilder.putAugmentedBuilder(
+        name,
+        AugmentedEnumDeclarationBuilder(
+          declaration: element,
+        ),
+      );
+    }
   }
 
   @override

pkg/analyzer/lib/src/summary2/element_flags.dart

@@ -83,15 +83,18 @@ class ConstructorElementFlags {
 
 class EnumElementFlags {
   static const int _isSimplyBounded = 1 << 0;
+  static const int _isAugmentation = 1 << 1;
 
   static void read(SummaryDataReader reader, EnumElementImpl element) {
     var byte = reader.readByte();
     element.isSimplyBounded = (byte & _isSimplyBounded) != 0;
+    element.isAugmentation = (byte & _isAugmentation) != 0;
   }
 
   static void write(BufferedSink sink, EnumElementImpl element) {
     var result = 0;
     result |= element.isSimplyBounded ? _isSimplyBounded : 0;
+    result |= element.isAugmentation ? _isAugmentation : 0;
     sink.writeByte(result);
   }
 }

pkg/analyzer/lib/src/summary2/library_builder.dart

@@ -58,6 +58,27 @@ class AugmentedClassDeclarationBuilder
   }
 }
 
+class AugmentedEnumDeclarationBuilder
+    extends AugmentedInstanceDeclarationBuilder {
+  final EnumElementImpl declaration;
+
+  AugmentedEnumDeclarationBuilder({
+    required this.declaration,
+  }) {
+    addFields(declaration.fields);
+    addConstructors(declaration.constructors);
+    addAccessors(declaration.accessors);
+    addMethods(declaration.methods);
+  }
+
+  void augment(EnumElementImpl element) {
+    addFields(element.fields);
+    addConstructors(element.constructors);
+    addAccessors(element.accessors);
+    addMethods(element.methods);
+  }
+}
+
 class AugmentedExtensionDeclarationBuilder
     extends AugmentedInstanceDeclarationBuilder {
   final ExtensionElementImpl declaration;
@@ -392,6 +413,40 @@ class LibraryBuilder with MacroApplicationsContainer {
     }
   }
 
+  void buildEnumSyntheticConstructors() {
+    bool hasConstructor(EnumElementImpl element) {
+      for (var constructor in element.augmented.constructors) {
+        if (constructor.isGenerative || constructor.name == '') {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    for (var enumElement in element.topLevelElements) {
+      if (enumElement is! EnumElementImpl) continue;
+      if (enumElement.augmentationTarget != null) continue;
+      if (hasConstructor(enumElement)) continue;
+
+      var constructor = ConstructorElementImpl('', -1)
+        ..isConst = true
+        ..isSynthetic = true;
+      var containerRef = enumElement.reference!.getChild('@constructor');
+      var reference = containerRef.getChild('new');
+      reference.element = constructor;
+      constructor.reference = reference;
+
+      enumElement.constructors = [
+        ...enumElement.constructors,
+        constructor,
+      ].toFixedList();
+
+      if (enumElement.augmented case AugmentedEnumElementImpl augmented) {
+        augmented.constructors = enumElement.constructors;
+      }
+    }
+  }
+
   void buildInitialExportScope() {
     exportScope = ExportScope();
     _declaredReferences.forEach((name, reference) {
@@ -719,12 +774,17 @@ class LibraryBuilder with MacroApplicationsContainer {
   }
 
   void resolveConstructorFieldFormals() {
-    for (var class_ in element.topLevelElements) {
-      if (class_ is! ClassElementImpl) continue;
-      if (class_.isMixinApplication) continue;
-      var augmented = class_.augmented;
+    for (var interface in element.topLevelElements) {
+      if (interface is! InterfaceElementImpl) {
+        continue;
+      }
+
+      if (interface is ClassElementImpl && interface.isMixinApplication) {
+        continue;
+      }
 
-      for (var constructor in class_.constructors) {
+      var augmented = interface.augmented;
+      for (var constructor in interface.constructors) {
         for (var parameter in constructor.parameters) {
           if (parameter is FieldFormalParameterElementImpl) {
             parameter.field = augmented.getField(parameter.name);

pkg/analyzer/lib/src/summary2/link.dart

@@ -124,6 +124,12 @@ class Linker {
     }
   }
 
+  void _buildEnumSyntheticConstructors() {
+    for (var library in builders.values) {
+      library.buildEnumSyntheticConstructors();
+    }
+  }
+
   void _buildExportScopes() {
     for (var library in builders.values) {
       library.buildInitialExportScope();
@@ -224,6 +230,7 @@ class Linker {
     );
 
     _buildClassSyntheticConstructors();
+    _buildEnumSyntheticConstructors();
     _replaceConstFieldsIfNoConstConstructor();
     _resolveConstructorFieldFormals();
     _buildEnumChildren();

pkg/analyzer/lib/src/summary2/types_builder.dart

@@ -268,15 +268,15 @@ class TypesBuilder {
   void _enumDeclaration(EnumDeclaration node) {
     var element = node.declaredElement as EnumElementImpl;
 
-    element.mixins = _toInterfaceTypeList(
-      node.withClause?.mixinTypes,
-    );
-
     element.interfaces = _toInterfaceTypeList(
       node.implementsClause?.interfaces,
     );
 
-    _toInferMixins[element] = _ToInferMixins(element, node.withClause);
+    if (element.augmentationTarget != null) {
+      _updatedAugmented(element, withClause: node.withClause);
+    } else {
+      _toInferMixins[element] = _ToInferMixins(element, node.withClause);
+    }
   }
 
   void _extensionDeclaration(ExtensionDeclaration node) {
@@ -687,9 +687,7 @@ class _MixinsInference {
   void perform() {
     for (var declaration in _declarations.values) {
       var element = declaration.element;
-      if (element is ClassElementImpl) {
-        element.mixinInferenceCallback = _callbackWhenRecursion;
-      }
+      element.mixinInferenceCallback = _callbackWhenRecursion;
     }
 
     for (var declaration in _declarations.values) {

pkg/analyzer/test/src/summary/element_text.dart

@@ -230,6 +230,13 @@ class _ElementWriter {
           writeConstructors();
           writeAccessors();
           writeMethods();
+        case AugmentedEnumElement():
+          _elementPrinter.writeTypeList('mixins', augmented.mixins);
+          _elementPrinter.writeTypeList('interfaces', augmented.interfaces);
+          writeFields();
+          writeConstructors();
+          writeAccessors();
+          writeMethods();
         case AugmentedExtensionElement():
           writeFields();
           writeAccessors();