Handle constructor invocation, is, as, throw, for-in and (a)sync(*) 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';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
 import '../kernel/kernel_debug.dart';
 import '../kernel/kernel_visitor.dart';
 import '../resolution/registry.dart' show ResolutionWorldImpactBuilder;
 import '../universe/feature.dart';
 import '../universe/selector.dart';
 import '../universe/use.dart';
 
 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.implementation;
+  AstElement element = resolvedAst.element;
   JavaScriptBackend backend = compiler.backend;
   Kernel kernel = backend.kernelTask.kernel;
   KernelImpactBuilder builder =
       new KernelImpactBuilder(resolvedAst, compiler, kernel);
   if (element.isFunction) {
     ir.Procedure function = kernel.functions[element];
     if (function == null) {
       print("FOUND NULL FUNCTION: $element");
     } else {
       return builder.buildProcedure(function);
@@ skipping 52 matching lines @@
       impactBuilder.registerFeature(Feature.FIELD_WITHOUT_INITIALIZER);
     }
     return impactBuilder;
   }
 
   ResolutionImpact buildProcedure(ir.Procedure procedure) {
     if (procedure.kind == ir.ProcedureKind.Method ||
         procedure.kind == ir.ProcedureKind.Operator) {
       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);
+          break;
+        case ir.AsyncMarker.AsyncStar:
+          impactBuilder.registerFeature(Feature.ASYNC_STAR);
+          break;
+        case ir.AsyncMarker.SyncYielding:
+          compiler.reporter.internalError(resolvedAst.element,
+              "Unexpected async marker: ${procedure.function.asyncMarker}");
+      }
     } 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);
@@ skipping 82 matching lines @@
     visitNode(entry.key);
     visitNode(entry.value);
   }
 
   void _visitArguments(ir.Arguments arguments) {
     arguments.positional.forEach(visitNode);
     arguments.named.forEach(visitNode);
   }
 
   @override
-  void visitStaticInvocation(ir.StaticInvocation invocation) {
-    _visitArguments(invocation.arguments);
-    Element target = astAdapter.getElement(invocation.target).declaration;
+  void visitConstructorInvocation(ir.ConstructorInvocation node) {
+    handleNew(node, node.target);
+  }
+
+  void handleNew(ir.InvocationExpression node, ir.Member target) {
+    _visitArguments(node.arguments);
+    Element element = astAdapter.getElement(target).declaration;
+    impactBuilder.registerStaticUse(new StaticUse.constructorInvoke(
+        element, astAdapter.getCallStructure(node.arguments)));
+    ClassElement cls = astAdapter.getElement(target.enclosingClass);
+    List<DartType> typeArguments =
+        astAdapter.getDartTypes(node.arguments.types);
+    impactBuilder.registerTypeUse(
+        new TypeUse.instantiation(new InterfaceType(cls, typeArguments)));
+    if (typeArguments.any((DartType type) => !type.isDynamic)) {
+      impactBuilder.registerFeature(Feature.TYPE_VARIABLE_BOUNDS_CHECK);
+    }
+  }
+
+  @override
+  void visitStaticInvocation(ir.StaticInvocation node) {
+    Element target = astAdapter.getElement(node.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
       // rather follow the type arguments directly.
       //
       // Consider this:
       //
       //    abstract class A<T> {
       //      factory A.regular() => new B<T>();
       //      factory A.redirect() = B<T>;
       //    }
       //
       //    class B<T> implements A<T> {}
       //
       //    main() {
       //      print(new A<int>.regular() is B<int>);
       //      print(new A<String>.redirect() is B<String>);
       //    }
       //
       // To track that B is actually instantiated as B<int> and B<String> we
       // need to follow the type arguments passed to A.regular and A.redirect
       // to B. Currently, we only do this soundly if we register A<int> and
       // A<String> as instantiated. We should instead register that A.T is
       // instantiated as int and String.
-      ClassElement cls =
-          astAdapter.getElement(invocation.target.enclosingClass);
-      List<DartType> typeArguments =
-          astAdapter.getDartTypes(invocation.arguments.types);
-      impactBuilder.registerTypeUse(
-          new TypeUse.instantiation(new InterfaceType(cls, typeArguments)));
-      if (typeArguments.any((DartType type) => !type.isDynamic)) {
-        impactBuilder.registerFeature(Feature.TYPE_VARIABLE_BOUNDS_CHECK);
-      }
+      handleNew(node, node.target);
     } else {
+      _visitArguments(node.arguments);
       impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
-          target, astAdapter.getCallStructure(invocation.arguments)));
+          target, astAdapter.getCallStructure(node.arguments)));
     }
   }
 
   @override
   void visitStaticGet(ir.StaticGet node) {
     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 {
@@ skipping 65 matching lines @@
   @override
   void visitVariableDeclaration(ir.VariableDeclaration node) {
     checkType(node.type);
     if (node.initializer != null) {
       visitNode(node.initializer);
     } else {
       impactBuilder.registerFeature(Feature.LOCAL_WITHOUT_INITIALIZER);
     }
   }
 
+  @override
+  void visitIsExpression(ir.IsExpression node) {
+    impactBuilder.registerTypeUse(
+        new TypeUse.isCheck(astAdapter.getDartType(node.type)));
+  }
+
+  @override
+  void visitAsExpression(ir.AsExpression node) {
+    impactBuilder
+        .registerTypeUse(new TypeUse.asCast(astAdapter.getDartType(node.type)));
+  }
+
+  @override
+  void visitThrow(ir.Throw node) {
+    impactBuilder.registerFeature(Feature.THROW_EXPRESSION);
+    visitNode(node.expression);
+  }
+
+  @override
+  void visitForInStatement(ir.ForInStatement node) {
+    visitNode(node.variable);
+    visitNode(node.iterable);
+    visitNode(node.body);
+    if (node.isAsync) {
+      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));
+  }
+
   // 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);
 }