Version 3.0.0-341.0.dev

Merge 21737a6 into dev

DEPS

@@ -145,7 +145,7 @@ vars = {
   "http_parser_rev": "b3b283b9f139640b932d604e8815460bbd3ecab5",
   "intl_rev": "fca552f2ec5d682b5fa36f02bdd72a5a4e2edcee",
   "json_rpc_2_rev": "0280ac6cb4f3905d81c47ba927123ba2b95f7940",
-  "linter_rev": "dcf3a079c573487b6ab64518604e5686be899601", # disable rev_sdk_deps.dart
+  "linter_rev": "07c4d177bca9e3b670ab67a7c9a8cffeb90aa318", # disable rev_sdk_deps.dart
   "lints_rev": "dfded5e265015f21ce154577fe8488dc244e33c2",
   "logging_rev": "abef3717d958158eb8b0ddb2871f4b15a9804cd4",
   "markdown_rev": "ecbffa9bf9109d490b9388e9cb1f2bb801aee63c",

pkg/analyzer/lib/src/dart/constant/evaluation.dart

@@ -32,21 +32,29 @@ import 'package:analyzer/src/task/api/model.dart';
 import 'package:analyzer/src/utilities/extensions/collection.dart';
 
 class ConstantEvaluationConfiguration {
-  /// During evaluation of enum constants we might need to report an error
-  /// that is associated with the [InstanceCreationExpression], but this
-  /// expression is synthetic. Instead, we remember the corresponding
-  /// [EnumConstantDeclaration] and report the error on it.
-  final Map<Expression, EnumConstantDeclaration> _enumConstants = {};
-
-  void addEnumConstant({
-    required EnumConstantDeclaration declaration,
-    required Expression initializer,
+  final Map<AstNode, AstNode> _errorNodes = {};
+
+  /// We evaluate constant values using expressions stored in elements.
+  /// But these expressions don't have offsets set.
+  /// This includes elements and expressions of the file being resolved.
+  /// So, to make sure that we report errors at right offsets, we "replace"
+  /// these constant expressions.
+  ///
+  /// A similar issue happens for enum values, which are desugared into
+  /// synthetic [InstanceCreationExpression], which never had any offsets.
+  /// So, we remember that any errors should be reported at the corresponding
+  /// [EnumConstantDeclaration]s.
+  void addErrorNode({
+    required AstNode? fromElement,
+    required AstNode? fromAst,
   }) {
-    _enumConstants[initializer] = declaration;
+    if (fromElement != null && fromAst != null) {
+      _errorNodes[fromElement] = fromAst;
+    }
   }
 
   AstNode errorNode(AstNode node) {
-    return _enumConstants[node] ?? node;
+    return _errorNodes[node] ?? node;
   }
 }
 
@@ -1418,7 +1426,8 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
 
     // TODO(https://github.com/dart-lang/sdk/issues/47061): Use a specific
     // error code.
-    _error(node, null);
+    final errorNode = evaluationEngine.configuration.errorNode(node);
+    _error(errorNode, null);
     return null;
   }
 

pkg/analyzer/lib/src/dart/constant/utilities.dart

@@ -159,10 +159,9 @@ class ConstantFinder extends RecursiveAstVisitor<void> {
     var element = node.declaredElement as ConstFieldElementImpl;
     constantsToCompute.add(element);
 
-    final initializer = element.constantInitializer!;
-    configuration.addEnumConstant(
-      declaration: node,
-      initializer: initializer,
+    configuration.addErrorNode(
+      fromElement: element.constantInitializer,
+      fromAst: node,
     );
   }
 
@@ -178,6 +177,14 @@ class ConstantFinder extends RecursiveAstVisitor<void> {
                 node.isFinal &&
                 !element.isStatic)) {
       constantsToCompute.add(element);
+      // Fill error nodes.
+      if (element is ConstVariableElement) {
+        final constElement = element as ConstVariableElement;
+        configuration.addErrorNode(
+          fromElement: constElement.constantInitializer,
+          fromAst: node.initializer,
+        );
+      }
     }
   }
 }

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

@@ -2070,7 +2070,7 @@ class ElementAnnotationImpl implements ElementAnnotation {
 
   /// The AST of the annotation itself, cloned from the resolved AST for the
   /// source code.
-  late Annotation annotationAst;
+  late AnnotationImpl annotationAst;
 
   /// The result of evaluating this annotation as a compile-time constant
   /// expression, or `null` if the compilation unit containing the variable has

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

@@ -2,7 +2,7 @@
 // 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.
 
-import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:collection/collection.dart';
 import 'package:pub_semver/pub_semver.dart';
@@ -57,7 +57,7 @@ class SinceSdkVersionComputer {
       if (annotation.isDartInternalSince) {
         final arguments = annotation.annotationAst.arguments?.arguments;
         final versionNode = arguments?.singleOrNull;
-        if (versionNode is SimpleStringLiteral) {
+        if (versionNode is SimpleStringLiteralImpl) {
           final versionStr = versionNode.value;
           final version = _parseVersion(versionStr);
           if (version != null) {

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

@@ -18,7 +18,6 @@ import 'package:analyzer/src/summary2/ast_binary_flags.dart';
 import 'package:analyzer/src/summary2/ast_binary_tag.dart';
 import 'package:analyzer/src/summary2/ast_binary_tokens.dart';
 import 'package:analyzer/src/summary2/bundle_reader.dart';
-import 'package:analyzer/src/summary2/not_serializable_nodes.dart';
 import 'package:analyzer/src/summary2/unlinked_token_type.dart';
 import 'package:collection/collection.dart';
 
@@ -83,8 +82,6 @@ class AstBinaryReader {
         return _readFieldFormalParameter();
       case Tag.FormalParameterList:
         return _readFormalParameterList();
-      case Tag.FunctionExpressionStub:
-        return _readFunctionExpression();
       case Tag.FunctionExpressionInvocation:
         return _readFunctionExpressionInvocation();
       case Tag.FunctionReference:
@@ -580,10 +577,6 @@ class AstBinaryReader {
     );
   }
 
-  FunctionExpression _readFunctionExpression() {
-    return emptyFunctionExpression();
-  }
-
   FunctionExpressionInvocation _readFunctionExpressionInvocation() {
     var function = readNode() as ExpressionImpl;
     var typeArguments = _readOptionalNode() as TypeArgumentListImpl?;

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

@@ -54,7 +54,6 @@ class Tag {
   static const int FormalParameterList = 17;
   static const int FunctionDeclaration_getter = 57;
   static const int FunctionDeclaration_setter = 58;
-  static const int FunctionExpressionStub = 19;
   static const int FunctionExpressionInvocation = 93;
   static const int FunctionReference = 103;
   static const int FunctionTypedFormalParameter = 20;

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

@@ -6,8 +6,6 @@ import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/type.dart';
-import 'package:analyzer/src/dart/ast/ast_factory.dart';
-import 'package:analyzer/src/dart/ast/token.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/summary2/ast_binary_flags.dart';
 import 'package:analyzer/src/summary2/ast_binary_tag.dart';
@@ -264,11 +262,6 @@ class AstBinaryWriter extends ThrowingAstVisitor<void> {
     _storeForEachParts(node);
   }
 
-  @override
-  void visitForElement(ForElement node) {
-    _writeNotSerializableExpression();
-  }
-
   @override
   void visitFormalParameterList(FormalParameterList node) {
     _writeByte(Tag.FormalParameterList);
@@ -298,11 +291,6 @@ class AstBinaryWriter extends ThrowingAstVisitor<void> {
     _storeForParts(node);
   }
 
-  @override
-  void visitFunctionExpression(FunctionExpression node) {
-    _writeByte(Tag.FunctionExpressionStub);
-  }
-
   @override
   void visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     _writeByte(Tag.FunctionExpressionInvocation);
@@ -952,13 +940,6 @@ class AstBinaryWriter extends ThrowingAstVisitor<void> {
     }
   }
 
-  void _writeNotSerializableExpression() {
-    var node = astFactory.simpleIdentifier(
-      StringToken(TokenType.STRING, '_notSerializableExpression', -1),
-    );
-    node.accept(this);
-  }
-
   void _writeOptionalNode(AstNode? node) {
     if (node == null) {
       _writeByte(Tag.Nothing);

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

@@ -1851,7 +1851,7 @@ class ResolutionReader {
     required CompilationUnitElementImpl unitElement,
   }) {
     return readTypedList(() {
-      var ast = _readRequiredNode() as Annotation;
+      var ast = _readRequiredNode() as AnnotationImpl;
       return ElementAnnotationImpl(unitElement)
         ..annotationAst = ast
         ..element = ast.element;

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

@@ -33,15 +33,32 @@ class _Visitor extends GeneralizingElementVisitor<void> {
       // Make a copy, so that it is not a NodeList.
       var initializers = element.constantInitializers.toFixedList();
       initializers.forEach(_detachNode);
+
+      for (final initializer in initializers) {
+        if (initializer is ConstructorFieldInitializerImpl) {
+          final expression = initializer.expression;
+          final replacement = replaceNotSerializableNode(expression);
+          initializer.expression = replacement;
+        }
+      }
+
       element.constantInitializers = initializers;
     }
     super.visitConstructorElement(element);
   }
 
   @override
   void visitElement(Element element) {
-    for (var elementAnnotation in element.metadata) {
-      _detachNode((elementAnnotation as ElementAnnotationImpl).annotationAst);
+    for (final annotation in element.metadata) {
+      final ast = (annotation as ElementAnnotationImpl).annotationAst;
+      _detachNode(ast);
+      // Sanitize arguments.
+      final arguments = ast.arguments?.arguments;
+      if (arguments != null) {
+        for (var i = 0; i < arguments.length; i++) {
+          arguments[i] = replaceNotSerializableNode(arguments[i]);
+        }
+      }
     }
     super.visitElement(element);
   }
@@ -75,7 +92,7 @@ class _Visitor extends GeneralizingElementVisitor<void> {
       if (initializer is ExpressionImpl) {
         _detachNode(initializer);
 
-        initializer = replaceNotSerializableNodes(initializer);
+        initializer = replaceNotSerializableNode(initializer);
         element.constantInitializer = initializer;
 
         ConstantContextForExpressionImpl(element, initializer);

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

@@ -15,6 +15,7 @@ import 'package:analyzer/src/summary2/bundle_reader.dart';
 import 'package:analyzer/src/summary2/data_reader.dart';
 import 'package:analyzer/src/summary2/data_writer.dart';
 import 'package:analyzer/src/summary2/linked_element_factory.dart';
+import 'package:analyzer/src/summary2/not_serializable_nodes.dart';
 import 'package:analyzer/src/util/collection.dart';
 import 'package:analyzer/src/util/comment.dart';
 import 'package:collection/collection.dart';
@@ -1803,6 +1804,15 @@ class _OffsetsApplier extends _OffsetsAstVisitor {
     }
   }
 
+  @override
+  void visitSimpleIdentifier(SimpleIdentifier node) {
+    if (isNotSerializableMarker(node)) {
+      return;
+    }
+
+    super.visitSimpleIdentifier(node);
+  }
+
   void _applyToEnumConstantInitializer(ConstFieldElementImpl element) {
     var initializer = element.constantInitializer;
     if (initializer is InstanceCreationExpression) {

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

@@ -3,59 +3,46 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
-import 'package:analyzer/src/dart/ast/utilities.dart';
-import 'package:analyzer/src/summary2/ast_binary_tokens.dart';
-
-FunctionExpressionImpl emptyFunctionExpression() {
-  return FunctionExpressionImpl(
-    typeParameters: null,
-    parameters: FormalParameterListImpl(
-      leftParenthesis: Tokens.openParenthesis(),
-      parameters: [],
-      leftDelimiter: null,
-      rightDelimiter: null,
-      rightParenthesis: Tokens.closeParenthesis(),
-    ),
-    body: BlockFunctionBodyImpl(
-      keyword: null,
-      star: null,
-      block: BlockImpl(
-        leftBracket: Tokens.openCurlyBracket(),
-        statements: [],
-        rightBracket: Tokens.closeCurlyBracket(),
-      ),
-    ),
-  );
+import 'package:analyzer/src/dart/ast/ast_factory.dart';
+import 'package:analyzer/src/dart/ast/token.dart';
+
+const _notSerializableName = '_notSerializableExpression';
+
+bool isNotSerializableMarker(SimpleIdentifier node) {
+  return node.name == _notSerializableName;
 }
 
-/// We cannot serialize [FunctionExpression], but we need to have some node
-/// with the same source range for error reporting. So, we replace them with
-/// empty [FunctionExpression]s that have the same offset and length.
-ExpressionImpl replaceNotSerializableNodes(ExpressionImpl node) {
-  if (node is FunctionExpressionImpl) {
-    return FunctionExpressionReplacementVisitor._replacement(node);
+/// If [node] is fully serializable, returns it.
+/// Otherwise returns a marker node.
+ExpressionImpl replaceNotSerializableNode(ExpressionImpl node) {
+  final visitor = _IsSerializableNodeVisitor();
+  node.accept(visitor);
+  if (visitor.result) {
+    return node;
   }
-  node.accept(FunctionExpressionReplacementVisitor());
-  return node;
+  return astFactory.simpleIdentifier(
+    StringToken(TokenType.STRING, _notSerializableName, -1),
+  );
 }
 
-class FunctionExpressionReplacementVisitor extends RecursiveAstVisitor<void> {
+class _IsSerializableNodeVisitor extends RecursiveAstVisitor<void> {
+  bool result = true;
+
   @override
-  void visitFunctionExpression(FunctionExpression node) {
-    NodeReplacer.replace(node, _replacement(node));
+  void visitForElement(ForElement node) {
+    result = false;
   }
 
-  static FunctionExpressionImpl _replacement(FunctionExpression from) {
-    var to = emptyFunctionExpression();
-    to.parameters?.leftParenthesis.offset = from.offset;
-
-    var toBody = to.body;
-    if (toBody is BlockFunctionBodyImpl) {
-      toBody.block.rightBracket.offset = from.end - 1;
-    }
+  @override
+  void visitFunctionExpression(FunctionExpression node) {
+    result = false;
+  }
 
-    return to;
+  @override
+  void visitSwitchExpression(SwitchExpression node) {
+    result = false;
   }
 }