Handle getters/setters and try in 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 11 matching lines @@
 import 'kernel_ast_adapter.dart';
 import '../common/resolution.dart';
 
 /// Computes the [ResolutionImpact] for [resolvedAst] through kernel.
 ResolutionImpact build(Compiler compiler, ResolvedAst resolvedAst) {
   AstElement element = resolvedAst.element;
   JavaScriptBackend backend = compiler.backend;
   Kernel kernel = backend.kernelTask.kernel;
   KernelImpactBuilder builder =
       new KernelImpactBuilder(resolvedAst, compiler, kernel);
-  if (element.isFunction) {
+  if (element.isFunction || element.isGetter || element.isSetter) {
     ir.Procedure function = kernel.functions[element];
     if (function == null) {
       print("FOUND NULL FUNCTION: $element");
     } else {
       return builder.buildProcedure(function);
     }
   } else {
     ir.Field field = kernel.fields[element];
     if (field == null) {
-      print("FOUND NULL FUNCTION: $element");
+      print("FOUND NULL FIELD: $element");
     } else {
       return builder.buildField(field);
     }
   }
   return null;
 }
 
 class KernelImpactBuilder extends ir.Visitor {
   final ResolvedAst resolvedAst;
   final Compiler compiler;
@@ skipping 33 matching lines @@
       if (!field.isConst) {
         impactBuilder.registerFeature(Feature.LAZY_FIELD);
       }
     } 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) {
+    if (procedure.kind != ir.ProcedureKind.Factory) {
       checkFunctionTypes(procedure.function);
       visitNode(procedure.function.body);
       switch (procedure.function.asyncMarker) {
         case ir.AsyncMarker.Sync:
           break;
         case ir.AsyncMarker.SyncStar:
           impactBuilder.registerFeature(Feature.SYNC_STAR);
           break;
         case ir.AsyncMarker.Async:
           impactBuilder.registerFeature(Feature.ASYNC);
@@ skipping 165 matching lines @@
     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 visitStaticSet(ir.StaticSet node) {
+    visitNode(node.value);
+    Element element = astAdapter.getElement(node.target).declaration;
+    impactBuilder.registerStaticUse(new StaticUse.staticSet(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 {
       visitNode(invocation.receiver);
       impactBuilder.registerDynamicUse(
           new DynamicUse(astAdapter.getSelector(invocation), null));
@@ skipping 84 matching lines @@
       impactBuilder.registerFeature(Feature.ASYNC_FOR_IN);
     } else {
       impactBuilder.registerFeature(Feature.SYNC_FOR_IN);
       impactBuilder
           .registerDynamicUse(new DynamicUse(Selectors.iterator, null));
     }
     impactBuilder.registerDynamicUse(new DynamicUse(Selectors.current, null));
     impactBuilder.registerDynamicUse(new DynamicUse(Selectors.moveNext, null));
   }
 
+  @override
+  void visitTryCatch(ir.TryCatch node) {
+    visitNode(node.body);
+    visitNodes(node.catches);
+  }
+
+  @override
+  void visitCatch(ir.Catch node) {
+    impactBuilder.registerFeature(Feature.CATCH_STATEMENT);
+    visitNode(node.exception);
+    if (node.stackTrace != null) {
+      impactBuilder.registerFeature(Feature.STACK_TRACE_IN_CATCH);
+    }
+    if (node.guard is! ir.DynamicType) {
+      impactBuilder.registerTypeUse(
+          new TypeUse.catchType(astAdapter.getDartType(node.guard)));
+    }
+    visitNode(node.body);
+  }
+
+  @override
+  void visitTryFinally(ir.TryFinally node) {
+    visitNode(node.body);

[Harry Terkelsen, 2016/09/27 17:12:37]

also visit the finalizer

[Johnni Winther, 2016/09/30 07:59:04]

Done.

+  }
+
   // 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);
 }