Version 2.13.0-85.0.dev

Merge commit 'e74b2391ed16034b0901f56bcf412c8d6ae8ae70' into 'dev'

Author: Dart CI

pkg/_fe_analyzer_shared/lib/src/messages/codes.dart

@@ -131,11 +131,11 @@ class LocatedMessage implements Comparable<LocatedMessage> {
     return message.compareTo(message);
   }
 
-  FormattedMessage withFormatting(String formatted, int line, int column,
-      Severity severity, List<FormattedMessage> relatedInformation,
+  FormattedMessage withFormatting(PlainAndColorizedString formatted, int line,
+      int column, Severity severity, List<FormattedMessage> relatedInformation,
       {List<Uri>? involvedFiles}) {
-    return new FormattedMessage(
-        this, formatted, line, column, severity, relatedInformation,
+    return new FormattedMessage(this, formatted.plain, formatted.colorized,
+        line, column, severity, relatedInformation,
         involvedFiles: involvedFiles);
   }
 
@@ -162,10 +162,20 @@ class LocatedMessage implements Comparable<LocatedMessage> {
       'messageObject=$messageObject)';
 }
 
+class PlainAndColorizedString {
+  final String plain;
+  final String colorized;
+
+  const PlainAndColorizedString(this.plain, this.colorized);
+  const PlainAndColorizedString.plainOnly(this.plain) : this.colorized = plain;
+}
+
 class FormattedMessage implements DiagnosticMessage {
   final LocatedMessage locatedMessage;
 
-  final String formatted;
+  final String formattedPlain;
+
+  final String formattedColorized;
 
   final int line;
 
@@ -178,8 +188,14 @@ class FormattedMessage implements DiagnosticMessage {
 
   final List<Uri>? involvedFiles;
 
-  const FormattedMessage(this.locatedMessage, this.formatted, this.line,
-      this.column, this.severity, this.relatedInformation,
+  const FormattedMessage(
+      this.locatedMessage,
+      this.formattedPlain,
+      this.formattedColorized,
+      this.line,
+      this.column,
+      this.severity,
+      this.relatedInformation,
       {this.involvedFiles});
 
   Code<dynamic> get code => locatedMessage.code;
@@ -200,18 +216,22 @@ class FormattedMessage implements DiagnosticMessage {
 
   @override
   Iterable<String> get ansiFormatted sync* {
-    yield formatted;
+    yield formattedColorized;
     if (relatedInformation != null) {
       for (FormattedMessage m in relatedInformation!) {
-        yield m.formatted;
+        yield m.formattedColorized;
       }
     }
   }
 
   @override
-  Iterable<String> get plainTextFormatted {
-    // TODO(ahe): Implement this correctly.
-    return ansiFormatted;
+  Iterable<String> get plainTextFormatted sync* {
+    yield formattedPlain;
+    if (relatedInformation != null) {
+      for (FormattedMessage m in relatedInformation!) {
+        yield m.formattedPlain;
+      }
+    }
   }
 
   Map<String, Object?> toJson() {

pkg/compiler/lib/src/ir/closure.dart

@@ -230,7 +230,7 @@ class VariableUse {
   final VariableUseKind kind;
   final ir.Member member;
   final ir.LocalFunction localFunction;
-  final ir.MethodInvocation invocation;
+  final ir.Expression invocation;
   final ir.Instantiation instantiation;
 
   const VariableUse._simple(this.kind)

pkg/compiler/lib/src/ir/scope_visitor.dart

@@ -933,6 +933,11 @@ class ScopeModelBuilder extends ir.Visitor<EvaluationComplexity>
     return const EvaluationComplexity.lazy();
   }
 
+  @override
+  EvaluationComplexity visitStaticTearOff(ir.StaticTearOff node) {
+    return _evaluateImplicitConstant(node);
+  }
+
   @override
   EvaluationComplexity visitStaticSet(ir.StaticSet node) {
     node.value = _handleExpression(node.value);
@@ -1029,6 +1034,108 @@ class ScopeModelBuilder extends ir.Visitor<EvaluationComplexity>
     if (receiverComplexity.combine(complexity).isConstant &&
         interfaceTarget is ir.Procedure &&
         interfaceTarget.kind == ir.ProcedureKind.Operator) {
+      // Only operator invocations can be part of constant expressions so we
+      // only try to compute an implicit constant when the receiver and all
+      // arguments are constant - and are used in an operator call.
+      return _evaluateImplicitConstant(node);
+    }
+    return const EvaluationComplexity.lazy();
+  }
+
+  @override
+  EvaluationComplexity visitInstanceInvocation(ir.InstanceInvocation node) {
+    node.receiver = _handleExpression(node.receiver);
+    EvaluationComplexity receiverComplexity = _lastExpressionComplexity;
+    if (node.arguments.types.isNotEmpty) {
+      ir.TreeNode receiver = node.receiver;
+      assert(
+          !(receiver is ir.VariableGet &&
+              receiver.variable.parent is ir.LocalFunction),
+          "Unexpected local function invocation ${node} "
+          "(${node.runtimeType}).");
+      VariableUse usage = new VariableUse.instanceTypeArgument(node);
+      visitNodesInContext(node.arguments.types, usage);
+    }
+    EvaluationComplexity complexity = visitArguments(node.arguments);
+    ir.Member interfaceTarget = node.interfaceTarget;
+    if (receiverComplexity.combine(complexity).isConstant &&
+        interfaceTarget is ir.Procedure &&
+        interfaceTarget.kind == ir.ProcedureKind.Operator) {
+      // Only operator invocations can be part of constant expressions so we
+      // only try to compute an implicit constant when the receiver and all
+      // arguments are constant - and are used in an operator call.
+      return _evaluateImplicitConstant(node);
+    }
+    return const EvaluationComplexity.lazy();
+  }
+
+  @override
+  EvaluationComplexity visitDynamicInvocation(ir.DynamicInvocation node) {
+    node.receiver = _handleExpression(node.receiver);
+    if (node.arguments.types.isNotEmpty) {
+      ir.TreeNode receiver = node.receiver;
+      assert(
+          !(receiver is ir.VariableGet &&
+              receiver.variable.parent is ir.LocalFunction),
+          "Unexpected local function invocation ${node} "
+          "(${node.runtimeType}).");
+      VariableUse usage = new VariableUse.instanceTypeArgument(node);
+      visitNodesInContext(node.arguments.types, usage);
+    }
+    visitArguments(node.arguments);
+    return const EvaluationComplexity.lazy();
+  }
+
+  @override
+  EvaluationComplexity visitFunctionInvocation(ir.FunctionInvocation node) {
+    node.receiver = _handleExpression(node.receiver);
+    if (node.arguments.types.isNotEmpty) {
+      assert(
+          !(node.receiver is ir.VariableGet &&
+              ((node.receiver as ir.VariableGet).variable.parent
+                  is ir.LocalFunction)),
+          "Unexpected local function invocation ${node} "
+          "(${node.runtimeType}).");
+      VariableUse usage = new VariableUse.instanceTypeArgument(node);
+      visitNodesInContext(node.arguments.types, usage);
+    }
+    visitArguments(node.arguments);
+    return const EvaluationComplexity.lazy();
+  }
+
+  @override
+  EvaluationComplexity visitLocalFunctionInvocation(
+      ir.LocalFunctionInvocation node) {
+    if (node.arguments.types.isNotEmpty) {
+      assert(
+          node.variable.parent is ir.LocalFunction,
+          "Unexpected variable in local function invocation ${node} "
+          "(${node.runtimeType}).");
+      VariableUse usage =
+          new VariableUse.localTypeArgument(node.variable.parent, node);
+      visitNodesInContext(node.arguments.types, usage);
+    }
+    visitArguments(node.arguments);
+    return const EvaluationComplexity.lazy();
+  }
+
+  @override
+  EvaluationComplexity visitEqualsNull(ir.EqualsNull node) {
+    node.expression = _handleExpression(node.expression);
+    EvaluationComplexity receiverComplexity = _lastExpressionComplexity;
+    if (receiverComplexity.isConstant) {
+      return _evaluateImplicitConstant(node);
+    }
+    return const EvaluationComplexity.lazy();
+  }
+
+  @override
+  EvaluationComplexity visitEqualsCall(ir.EqualsCall node) {
+    node.left = _handleExpression(node.left);
+    EvaluationComplexity leftComplexity = _lastExpressionComplexity;
+    node.right = _handleExpression(node.right);
+    EvaluationComplexity rightComplexity = _lastExpressionComplexity;
+    if (leftComplexity.combine(rightComplexity).isConstant) {
       return _evaluateImplicitConstant(node);
     }
     return const EvaluationComplexity.lazy();
@@ -1044,13 +1151,59 @@ class ScopeModelBuilder extends ir.Visitor<EvaluationComplexity>
     return const EvaluationComplexity.lazy();
   }
 
+  @override
+  EvaluationComplexity visitInstanceGet(ir.InstanceGet node) {
+    node.receiver = _handleExpression(node.receiver);
+    EvaluationComplexity complexity = _lastExpressionComplexity;
+    if (complexity.isConstant && node.name.name == 'length') {
+      return _evaluateImplicitConstant(node);
+    }
+    return const EvaluationComplexity.lazy();
+  }
+
+  @override
+  EvaluationComplexity visitInstanceTearOff(ir.InstanceTearOff node) {
+    node.receiver = _handleExpression(node.receiver);
+    return const EvaluationComplexity.lazy();
+  }
+
+  @override
+  EvaluationComplexity visitDynamicGet(ir.DynamicGet node) {
+    node.receiver = _handleExpression(node.receiver);
+    EvaluationComplexity complexity = _lastExpressionComplexity;
+    if (complexity.isConstant && node.name.name == 'length') {
+      return _evaluateImplicitConstant(node);
+    }
+    return const EvaluationComplexity.lazy();
+  }
+
+  @override
+  EvaluationComplexity visitFunctionTearOff(ir.FunctionTearOff node) {
+    node.receiver = _handleExpression(node.receiver);
+    return const EvaluationComplexity.lazy();
+  }
+
   @override
   EvaluationComplexity visitPropertySet(ir.PropertySet node) {
     node.receiver = _handleExpression(node.receiver);
     node.value = _handleExpression(node.value);
     return const EvaluationComplexity.lazy();
   }
 
+  @override
+  EvaluationComplexity visitInstanceSet(ir.InstanceSet node) {
+    node.receiver = _handleExpression(node.receiver);
+    node.value = _handleExpression(node.value);
+    return const EvaluationComplexity.lazy();
+  }
+
+  @override
+  EvaluationComplexity visitDynamicSet(ir.DynamicSet node) {
+    node.receiver = _handleExpression(node.receiver);
+    node.value = _handleExpression(node.value);
+    return const EvaluationComplexity.lazy();
+  }
+
   @override
   EvaluationComplexity visitNot(ir.Not node) {
     node.operand = _handleExpression(node.operand);

pkg/compiler/lib/src/serialization/node_indexer.dart

@@ -111,18 +111,90 @@ class _TreeNodeIndexerVisitor extends ir.Visitor<void>
     super.visitPropertyGet(node);
   }
 
+  @override
+  void visitInstanceGet(ir.InstanceGet node) {
+    registerNode(node);
+    super.visitInstanceGet(node);
+  }
+
+  @override
+  void visitInstanceTearOff(ir.InstanceTearOff node) {
+    registerNode(node);
+    super.visitInstanceTearOff(node);
+  }
+
+  @override
+  void visitDynamicGet(ir.DynamicGet node) {
+    registerNode(node);
+    super.visitDynamicGet(node);
+  }
+
+  @override
+  void visitFunctionTearOff(ir.FunctionTearOff node) {
+    registerNode(node);
+    super.visitFunctionTearOff(node);
+  }
+
   @override
   void visitPropertySet(ir.PropertySet node) {
     registerNode(node);
     super.visitPropertySet(node);
   }
 
+  @override
+  void visitInstanceSet(ir.InstanceSet node) {
+    registerNode(node);
+    super.visitInstanceSet(node);
+  }
+
+  @override
+  void visitDynamicSet(ir.DynamicSet node) {
+    registerNode(node);
+    super.visitDynamicSet(node);
+  }
+
   @override
   void visitMethodInvocation(ir.MethodInvocation node) {
     registerNode(node);
     super.visitMethodInvocation(node);
   }
 
+  @override
+  void visitInstanceInvocation(ir.InstanceInvocation node) {
+    registerNode(node);
+    super.visitInstanceInvocation(node);
+  }
+
+  @override
+  void visitDynamicInvocation(ir.DynamicInvocation node) {
+    registerNode(node);
+    super.visitDynamicInvocation(node);
+  }
+
+  @override
+  void visitFunctionInvocation(ir.FunctionInvocation node) {
+    registerNode(node);
+    super.visitFunctionInvocation(node);
+  }
+
+  @override
+  void visitLocalFunctionInvocation(ir.LocalFunctionInvocation node) {
+    registerNode(node);
+    super.visitLocalFunctionInvocation(node);
+  }
+
+  @override
+  void visitEqualsNull(ir.EqualsNull node) {
+    registerNode(node);
+    super.visitEqualsNull(node);
+  }
+
+  @override
+  void visitEqualsCall(ir.EqualsCall node) {
+    registerNode(node);
+    super.visitEqualsCall(node);
+  }
+
   @override
   void visitStaticInvocation(ir.StaticInvocation node) {
     registerNode(node);