Version 3.5.0-81.0.dev

Merge cc9de33 into dev

PRESUBMIT.py

@@ -329,6 +329,57 @@ def _CheckClangTidy(input_api, output_api):
     ]
 
 
+def _CheckClangFormat(input_api, output_api):
+    """Run clang-format on VM changes."""
+
+    # Only run clang-format on linux x64.
+    if platform.system() != 'Linux' or platform.machine() != 'x86_64':
+        return []
+
+    # Run only for modified .cc or .h files, except for DEPS changes.
+    files = []
+    is_deps = False
+    for f in input_api.AffectedFiles():
+        path = f.LocalPath()
+        if path == 'DEPS' and any(
+                map(lambda content: 'clang' in content[1],
+                    f.ChangedContents())):
+            is_deps = True
+            break
+        if is_cpp_file(path) and os.path.isfile(path):
+            files.append(path)
+
+    if is_deps:
+        find_args = [
+            'find',
+            'runtime/',
+            '-iname',
+            '*.h',
+            '-o',
+            '-iname',
+            '*.cc',
+        ]
+        files = subprocess.check_output(find_args, text=True).split()
+
+    if not files:
+        return []
+
+    args = [
+        'buildtools/linux-x64/clang/bin/clang-format',
+        '--dry-run',
+        '--Werror',
+    ]
+    args.extend(files)
+    stdout = input_api.subprocess.check_output(args).strip()
+    if not stdout:
+        return []
+
+    return [
+        output_api.PresubmitError('The `clang-format` revealed issues:',
+                                  long_text=stdout)
+    ]
+
+
 def _CheckAnalyzerFiles(input_api, output_api):
     """Run analyzer checks on source files."""
 
@@ -469,6 +520,7 @@ def _CommonChecks(input_api, output_api):
     results.extend(_CheckStatusFiles(input_api, output_api))
     results.extend(_CheckLayering(input_api, output_api))
     results.extend(_CheckClangTidy(input_api, output_api))
+    results.extend(_CheckClangFormat(input_api, output_api))
     results.extend(_CheckTestMatrixValid(input_api, output_api))
     results.extend(
         input_api.canned_checks.CheckPatchFormatted(input_api, output_api))

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

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

pkg/analyzer/lib/dart/element/element.dart

@@ -86,6 +86,9 @@ abstract class AugmentedClassElement implements AugmentedInterfaceElement {
 ///
 /// Clients may not extend, implement or mix-in this class.
 abstract class AugmentedEnumElement implements AugmentedInterfaceElement {
+  /// The enum constants declared in this element.
+  List<FieldElement> get constants;
+
   @override
   EnumElement get declaration;
 }

pkg/analyzer/lib/src/dart/element/element.dart

@@ -4953,6 +4953,11 @@ mixin MaybeAugmentedClassElementMixin on MaybeAugmentedInterfaceElementMixin
 
 mixin MaybeAugmentedEnumElementMixin on MaybeAugmentedInterfaceElementMixin
     implements AugmentedEnumElement {
+  @override
+  List<FieldElement> get constants {
+    return fields.where((field) => field.isEnumConstant).toList();
+  }
+
   @override
   EnumElementImpl get declaration;
 }

pkg/analyzer/lib/src/fasta/ast_builder.dart

@@ -4446,11 +4446,19 @@ class AstBuilder extends StackListener {
     } else if (context == IdentifierContext.enumValueDeclaration) {
       var metadata = pop() as List<AnnotationImpl>?;
       var comment = _findComment(metadata, token);
+
+      Token? augmentKeyword;
+      if (token.previous case var previous?) {
+        if (optional('augment', previous)) {
+          augmentKeyword = previous;
+        }
+      }
+
       push(
         EnumConstantDeclarationImpl(
           comment: comment,
           metadata: metadata,
-          augmentKeyword: null,
+          augmentKeyword: augmentKeyword,
           name: token,
           arguments: null,
         ),

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

@@ -18,6 +18,7 @@ import 'package:analyzer/src/summary2/reference.dart';
 import 'package:analyzer/src/util/comment.dart';
 import 'package:analyzer/src/utilities/extensions/collection.dart';
 import 'package:analyzer/src/utilities/extensions/string.dart';
+import 'package:collection/collection.dart';
 
 class ElementBuilder extends ThrowingAstVisitor<void> {
   final LibraryBuilder _libraryBuilder;
@@ -266,13 +267,15 @@ class ElementBuilder extends ThrowingAstVisitor<void> {
 
     // Build fields for all enum constants.
     var constants = node.constants;
-    var valuesElements = <ExpressionImpl>[];
+    var valuesElements = <SimpleIdentifierImpl>[];
+    var valuesNames = <String>{};
     for (var i = 0; i < constants.length; ++i) {
       var constant = constants[i];
       var name = constant.name.lexeme;
       var field = ConstFieldElementImpl(name, constant.name.offset)
         ..hasImplicitType = true
         ..hasInitializer = true
+        ..isAugmentation = constant.augmentKeyword != null
         ..isConst = true
         ..isEnumConstant = true
         ..isStatic = true;
@@ -336,6 +339,7 @@ class ElementBuilder extends ThrowingAstVisitor<void> {
           StringToken(TokenType.STRING, name, -1),
         ),
       );
+      valuesNames.add(name);
     }
 
     // Build the 'values' field.
@@ -387,13 +391,34 @@ class ElementBuilder extends ThrowingAstVisitor<void> {
 
       holder.addNonSyntheticField(valuesField);
 
-      _libraryBuilder.implicitEnumNodes.add(
-        ImplicitEnumNodes(
-          element: element,
-          valuesTypeNode: valuesTypeNode,
-          valuesField: valuesField,
-        ),
+      _libraryBuilder.implicitEnumNodes[element] = ImplicitEnumNodes(
+        element: element,
+        valuesTypeNode: valuesTypeNode,
+        valuesNode: variableDeclaration,
+        valuesElement: valuesField,
+        valuesNames: valuesNames,
+        valuesInitializer: initializer,
       );
+    } else {
+      var declaration = element.augmented.declaration;
+      var implicitNodes = _libraryBuilder.implicitEnumNodes[declaration];
+      if (implicitNodes != null) {
+        var mergedValuesElements = [
+          ...implicitNodes.valuesInitializer.elements,
+          for (var value in valuesElements)
+            if (implicitNodes.valuesNames.add(value.name)) value,
+        ];
+        var initializer = ListLiteralImpl(
+          constKeyword: null,
+          typeArguments: null,
+          leftBracket: Tokens.openSquareBracket(),
+          elements: mergedValuesElements,
+          rightBracket: Tokens.closeSquareBracket(),
+        );
+        implicitNodes.valuesElement.constantInitializer = initializer;
+        implicitNodes.valuesNode.initializer = initializer;
+        implicitNodes.valuesInitializer = initializer;
+      }
     }
 
     node.withClause?.accept(this);

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

@@ -50,12 +50,18 @@ class DefiningLinkingUnit extends LinkingUnit {
 class ImplicitEnumNodes {
   final EnumElementImpl element;
   final ast.NamedTypeImpl valuesTypeNode;
-  final ConstFieldElementImpl valuesField;
+  final ast.VariableDeclarationImpl valuesNode;
+  final ConstFieldElementImpl valuesElement;
+  final Set<String> valuesNames;
+  ast.ListLiteralImpl valuesInitializer;
 
   ImplicitEnumNodes({
     required this.element,
     required this.valuesTypeNode,
-    required this.valuesField,
+    required this.valuesNode,
+    required this.valuesElement,
+    required this.valuesNames,
+    required this.valuesInitializer,
   });
 }
 
@@ -69,7 +75,8 @@ class LibraryBuilder with MacroApplicationsContainer {
   final LibraryElementImpl element;
   final List<LinkingUnit> units;
 
-  final List<ImplicitEnumNodes> implicitEnumNodes = [];
+  final Map<EnumElementImpl, ImplicitEnumNodes> implicitEnumNodes =
+      Map.identity();
 
   /// The top-level elements that can be augmented.
   final Map<String, AugmentedInstanceDeclarationBuilder> _augmentedBuilders =
@@ -219,7 +226,7 @@ class LibraryBuilder with MacroApplicationsContainer {
 
   void buildEnumChildren() {
     var typeProvider = element.typeProvider;
-    for (var enum_ in implicitEnumNodes) {
+    for (var enum_ in implicitEnumNodes.values) {
       enum_.element.supertype =
           typeProvider.enumType ?? typeProvider.objectType;
       var valuesType = typeProvider.listType(
@@ -229,7 +236,7 @@ class LibraryBuilder with MacroApplicationsContainer {
         ),
       );
       enum_.valuesTypeNode.type = valuesType;
-      enum_.valuesField.type = valuesType;
+      enum_.valuesElement.type = valuesType;
     }
   }
 

pkg/analyzer/test/src/dart/parser/enum_test.dart

@@ -38,6 +38,31 @@ EnumDeclaration
 ''');
   }
 
+  test_augment_constant_augment_noConstructor() {
+    var parseResult = parseStringWithErrors(r'''
+augment library 'a.dart';
+
+augment enum E {
+  augment v
+}
+''');
+    parseResult.assertNoErrors();
+
+    var node = parseResult.findNode.singleEnumDeclaration;
+    assertParsedNodeText(node, r'''
+EnumDeclaration
+  augmentKeyword: augment
+  enumKeyword: enum
+  name: E
+  leftBracket: {
+  constants
+    EnumConstantDeclaration
+      augmentKeyword: augment
+      name: v
+  rightBracket: }
+''');
+  }
+
   test_augment_constant_augment_withConstructor() {
     var parseResult = parseStringWithErrors(r'''
 augment library 'a.dart';

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

@@ -234,6 +234,10 @@ class _ElementWriter {
           _elementPrinter.writeTypeList('mixins', augmented.mixins);
           _elementPrinter.writeTypeList('interfaces', augmented.interfaces);
           writeFields();
+          _elementPrinter.writeElementList(
+            'constants',
+            augmented.constants.sortedBy((e) => e.name),
+          );
           writeConstructors();
           writeAccessors();
           writeMethods();