More kernel_impact.

pkg/compiler/lib/src/ssa/kernel_impact.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // 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:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 54 matching lines @@
 
   /// Add a checked-mode type use of [type] if it is not `dynamic`.
   DartType checkType(ir.DartType irType) {
     DartType type = astAdapter.getDartType(irType);
     if (!type.isDynamic) {
       impactBuilder.registerTypeUse(new TypeUse.checkedModeCheck(type));
     }
     return type;
   }
 
+  /// Add a checked-mode type use of return type and parameters of [node].
+  void checkFunctionTypes(ir.FunctionNode node) {
+    checkType(node.returnType);
+    node.positionalParameters.forEach((v) => checkType(v.type));
+    node.namedParameters.forEach((v) => checkType(v.type));
+  }
+
   ResolutionImpact buildField(ir.Field field) {
     checkType(field.type);
     if (field.initializer != null) {
-      field.initializer.accept(this);
+      visitNode(field.initializer);
     } else {
       impactBuilder.registerFeature(Feature.FIELD_WITHOUT_INITIALIZER);
     }
     return impactBuilder;
   }
 
   ResolutionImpact buildProcedure(ir.Procedure procedure) {
     if (procedure.kind == ir.ProcedureKind.Method ||
         procedure.kind == ir.ProcedureKind.Operator) {
-      checkType(procedure.function.returnType);
-      procedure.function.positionalParameters.forEach((v) => checkType(v.type));
-      procedure.function.namedParameters.forEach((v) => checkType(v.type));
-      procedure.function.body.accept(this);
+      checkFunctionTypes(procedure.function);
+      visitNode(procedure.function.body);
     } else {
       compiler.reporter.internalError(
           resolvedAst.element,
           "Unable to compute resolution impact for this kind of Kernel "
           "procedure: ${procedure.kind}");
     }
     return impactBuilder;
   }
 
+  void visitNode(ir.Node node) => node?.accept(this);
+
   void visitNodes(Iterable<ir.Node> nodes) {
-    nodes.forEach((ir.Node node) => node.accept(this));
+    nodes.forEach(visitNode);
   }
 
   @override
   void visitBlock(ir.Block block) => visitNodes(block.statements);
 
   @override
   void visitExpressionStatement(ir.ExpressionStatement exprStatement) {
-    exprStatement.expression.accept(this);
+    visitNode(exprStatement.expression);
   }
 
   @override
   void visitReturnStatement(ir.ReturnStatement returnStatement) {
-    returnStatement.expression?.accept(this);
+    visitNode(returnStatement.expression);
   }
 
   @override
   void visitIfStatement(ir.IfStatement ifStatement) {
-    ifStatement.condition.accept(this);
-    ifStatement.then.accept(this);
-    ifStatement.otherwise?.accept(this);
+    visitNode(ifStatement.condition);
+    visitNode(ifStatement.then);
+    visitNode(ifStatement.otherwise);
   }
 
   @override
   void visitIntLiteral(ir.IntLiteral literal) {
     impactBuilder
         .registerConstantLiteral(new IntConstantExpression(literal.value));
   }
 
   @override
   void visitDoubleLiteral(ir.DoubleLiteral literal) {
@@ skipping 39 matching lines @@
     visitNodes(literal.entries);
     DartType keyType = checkType(literal.keyType);
     DartType valueType = checkType(literal.valueType);
     impactBuilder.registerMapLiteral(new MapLiteralUse(
         compiler.coreTypes.mapType(keyType, valueType),
         isConstant: literal.isConst,
         isEmpty: literal.entries.isEmpty));
   }
 
   void visitMapEntry(ir.MapEntry entry) {
-    entry.key.accept(this);
-    entry.value.accept(this);
+    visitNode(entry.key);
+    visitNode(entry.value);
   }
 
   void _visitArguments(ir.Arguments arguments) {
-    for (ir.Expression argument in arguments.positional) {
-      argument.accept(this);
-    }
-    for (ir.NamedExpression argument in arguments.named) {
-      argument.value.accept(this);
-    }
+    arguments.positional.forEach(visitNode);
+    arguments.named.forEach(visitNode);
   }
 
   @override
   void visitStaticInvocation(ir.StaticInvocation invocation) {
     _visitArguments(invocation.arguments);
     Element target = astAdapter.getElement(invocation.target).declaration;
     if (target.isFactoryConstructor) {
       impactBuilder.registerStaticUse(new StaticUse.constructorInvoke(
           target, astAdapter.getCallStructure(invocation.arguments)));
       // TODO(johnniwinther): We should not mark the type as instantiated but
@@ skipping 28 matching lines @@
         impactBuilder.registerFeature(Feature.TYPE_VARIABLE_BOUNDS_CHECK);
       }
     } else {
       impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
           target, astAdapter.getCallStructure(invocation.arguments)));
     }
   }
 
   @override
   void visitStaticGet(ir.StaticGet node) {
-    Element target = astAdapter.getElement(node.target).declaration;
-    impactBuilder.registerStaticUse(new StaticUse.staticGet(target));
+    ir.Member target = node.target;
+    Element element = astAdapter.getElement(target).declaration;
+    if (target is ir.Procedure && target.kind == ir.ProcedureKind.Method) {
+      impactBuilder.registerStaticUse(new StaticUse.staticTearOff(element));
+    } else {
+      impactBuilder.registerStaticUse(new StaticUse.staticGet(element));
+    }
   }
 
   @override
   void visitMethodInvocation(ir.MethodInvocation invocation) {
     var receiver = invocation.receiver;
     if (receiver is ir.VariableGet &&
         receiver.variable.isFinal &&
         receiver.variable.parent is ir.FunctionDeclaration) {
       // Invocation of a local function. No need for dynamic use.
     } else {
-      invocation.receiver.accept(this);
+      visitNode(invocation.receiver);
       impactBuilder.registerDynamicUse(
           new DynamicUse(astAdapter.getSelector(invocation), null));
     }
     _visitArguments(invocation.arguments);
   }
 
   @override
   void visitPropertyGet(ir.PropertyGet node) {
-    node.receiver.accept(this);
+    visitNode(node.receiver);
     impactBuilder.registerDynamicUse(new DynamicUse(
         new Selector.getter(astAdapter.getName(node.name)), null));
   }
 
   @override
   void visitPropertySet(ir.PropertySet node) {
-    node.receiver.accept(this);
-    node.value.accept(this);
+    visitNode(node.receiver);
+    visitNode(node.value);
     impactBuilder.registerDynamicUse(new DynamicUse(
         new Selector.setter(astAdapter.getName(node.name)), null));
   }
 
   @override
   void visitAssertStatement(ir.AssertStatement node) {
     impactBuilder.registerFeature(
         node.message != null ? Feature.ASSERT_WITH_MESSAGE : Feature.ASSERT);
-    node.visitChildren(this);
+    visitNode(node.condition);
+    visitNode(node.message);
   }
 
   @override
   void visitStringConcatenation(ir.StringConcatenation node) {
     impactBuilder.registerFeature(Feature.STRING_INTERPOLATION);
     impactBuilder.registerFeature(Feature.STRING_JUXTAPOSITION);
-    node.visitChildren(this);
+    visitNodes(node.expressions);
   }
 
   @override
   void visitFunctionDeclaration(ir.FunctionDeclaration node) {
     impactBuilder
         .registerStaticUse(new StaticUse.closure(astAdapter.getElement(node)));
-    node.visitChildren(this);
+    checkFunctionTypes(node.function);
+    visitNode(node.function.body);
   }
 
   @override
+  void visitFunctionExpression(ir.FunctionExpression node) {
+    impactBuilder
+        .registerStaticUse(new StaticUse.closure(astAdapter.getElement(node)));
+    checkFunctionTypes(node.function);
+    visitNode(node.function.body);
+  }
+
+  @override
+  void visitVariableDeclaration(ir.VariableDeclaration node) {
+    checkType(node.type);
+    if (node.initializer != null) {
+      visitNode(node.initializer);
+    } else {
+      impactBuilder.registerFeature(Feature.LOCAL_WITHOUT_INITIALIZER);
+    }
+  }
+
+  // TODO(johnniwinther): Make this throw and visit child nodes explicitly
+  // instead to ensure that we don't visit unwanted parts of the ir.
+  @override
   void defaultNode(ir.Node node) => node.visitChildren(this);
 }