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);
     } 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));
+      checkFunctionTypes(procedure.function);
       procedure.function.body.accept(this);
     } 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);

[Harry Terkelsen, 2016/09/22 19:20:15]

if you have this, you should use it consistently throughout the visitor. i.e.,
no instances of x.accept(this)

[Johnni Winther, 2016/09/23 09:01:50]

I thought I had ;) - Done.

+
   void visitNodes(Iterable<ir.Node> nodes) {
     nodes.forEach((ir.Node node) => node.accept(this));
   }
 
   @override
   void visitBlock(ir.Block block) => visitNodes(block.statements);
 
   @override
   void visitExpressionStatement(ir.ExpressionStatement exprStatement) {
     exprStatement.expression.accept(this);
@@ skipping 120 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 {
@@ skipping 16 matching lines @@
     node.receiver.accept(this);
     node.value.accept(this);
     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);
 }