Fine. Support for more constant expressions.

Found a few missing cases while running over Flutter.

We only need to support valid constant expressions, because we serialize
only constant expressions. So, it is OK to say that if there was invalid
expression, it does not match with any expression, we will consider it
invalidated until the user fixes the code. We support this with
`isValid` flag now.

* Added support for `identical()`.
* Added support for `ImportPrefixReference`.
* Added support for `SymbolLiteral`.

Change-Id: Ief8714f281cd49b62d242bf85e92c2531b79af95
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/443623
Reviewed-by: Johnni Winther <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/fine/manifest_ast.dart

@@ -43,12 +43,18 @@ enum ManifestAstElementKind {
 
 /// Enough information to decide if the node is the same.
 ///
+/// We used it to store information AST nodes exposed through the element
+/// model: constant initializers, constructor initializers, and annotations.
+///
 /// We don't store ASTs, instead we rely on the fact that the same tokens
 /// are parsed into the same AST (when the same language features, which is
 /// ensured outside).
 ///
 /// In addition we record all referenced elements.
 class ManifestNode {
+  /// Whether the encoded AST node has only nodes that we support.
+  final bool isValid;
+
   /// The concatenated lexemes of all tokens.
   final String tokenBuffer;
 
@@ -86,19 +92,31 @@ class ManifestNode {
     );
     node.accept(collector);
 
-    return ManifestNode._(
-      tokenBuffer: buffer.toString(),
-      tokenLengthList: Uint32List.fromList(lengthList),
-      elements:
-          collector.map.keys
-              .map((element) => ManifestElement.encode(context, element))
-              .toFixedList(),
-      elementIndexList: Uint32List.fromList(collector.elementIndexList),
-    );
+    if (collector.isValid) {
+      return ManifestNode._(
+        isValid: true,
+        tokenBuffer: buffer.toString(),
+        tokenLengthList: Uint32List.fromList(lengthList),
+        elements:
+            collector.map.keys
+                .map((element) => ManifestElement.encode(context, element))
+                .toFixedList(),
+        elementIndexList: Uint32List.fromList(collector.elementIndexList),
+      );
+    } else {
+      return ManifestNode._(
+        isValid: false,
+        tokenBuffer: '',
+        tokenLengthList: Uint32List(0),
+        elements: const [],
+        elementIndexList: Uint32List(0),
+      );
+    }
   }
 
   factory ManifestNode.read(SummaryDataReader reader) {
     return ManifestNode._(
+      isValid: reader.readBool(),
       tokenBuffer: reader.readStringUtf8(),
       tokenLengthList: reader.readUInt30List(),
       elements: ManifestElement.readList(reader),
@@ -107,13 +125,18 @@ class ManifestNode {
   }
 
   ManifestNode._({
+    required this.isValid,
     required this.tokenBuffer,
     required this.tokenLengthList,
     required this.elements,
     required this.elementIndexList,
   });
 
   bool match(MatchContext context, AstNode node) {
+    if (!isValid) {
+      return false;
+    }
+
     var tokenIndex = 0;
     var tokenOffset = 0;
     var token = node.beginToken;
@@ -162,6 +185,7 @@ class ManifestNode {
   }
 
   void write(BufferedSink sink) {
+    sink.writeBool(isValid);
     sink.writeStringUtf8(tokenBuffer);
     sink.writeUint30List(tokenLengthList);
     sink.writeList(elements, (e) => e.write(sink));
@@ -177,7 +201,8 @@ class ManifestNode {
   }
 }
 
-class _ElementCollector extends ThrowingAstVisitor<void> {
+class _ElementCollector extends GeneralizingAstVisitor<void> {
+  bool isValid = true;
   final int Function(TypeParameterElementImpl) indexOfTypeParameter;
   final int Function(FormalParameterElementImpl) indexOfFormalParameter;
   final Map<Element, int> map = Map.identity();
@@ -257,6 +282,11 @@ class _ElementCollector extends ThrowingAstVisitor<void> {
     node.visitChildren(this);
   }
 
+  @override
+  void visitImportPrefixReference(ImportPrefixReference node) {
+    _addElement(node.element);
+  }
+
   @override
   void visitInstanceCreationExpression(InstanceCreationExpression node) {
     node.visitChildren(this);
@@ -288,6 +318,17 @@ class _ElementCollector extends ThrowingAstVisitor<void> {
     node.visitChildren(this);
   }
 
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    if (node.methodName.element case TopLevelFunctionElement element) {
+      if (element.isDartCoreIdentical) {
+        node.visitChildren(this);
+        return;
+      }
+    }
+    isValid = false;
+  }
+
   @override
   void visitNamedExpression(NamedExpression node) {
     node.expression.accept(this);
@@ -299,6 +340,11 @@ class _ElementCollector extends ThrowingAstVisitor<void> {
     _addElement(node.element);
   }
 
+  @override
+  void visitNode(AstNode node) {
+    isValid = false;
+  }
+
   @override
   void visitNullLiteral(NullLiteral node) {}
 
@@ -364,6 +410,9 @@ class _ElementCollector extends ThrowingAstVisitor<void> {
     node.visitChildren(this);
   }
 
+  @override
+  void visitSymbolLiteral(SymbolLiteral node) {}
+
   @override
   void visitTypeArgumentList(TypeArgumentList node) {
     node.visitChildren(this);