More functionality 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/call_structure.dart';
 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;
-  JavaScriptBackend backend = compiler.backend;
-  Kernel kernel = backend.kernelTask.kernel;
-  KernelImpactBuilder builder =
-      new KernelImpactBuilder(resolvedAst, compiler, kernel);
-  if (element.isFunction ||
-      element.isGetter ||
-      element.isSetter ||
-      element.isFactoryConstructor) {
-    ir.Procedure function = kernel.functions[element];
-    if (function == null) {
-      throw "FOUND NULL FUNCTION: $element";
+  return compiler.reporter.withCurrentElement(element.implementation, () {
+    JavaScriptBackend backend = compiler.backend;
+    Kernel kernel = backend.kernelTask.kernel;
+    KernelImpactBuilder builder =
+        new KernelImpactBuilder(resolvedAst, compiler, kernel);
+    if (element.isFunction ||
+        element.isGetter ||
+        element.isSetter ||
+        element.isFactoryConstructor) {
+      ir.Procedure function = kernel.functions[element];
+      if (function == null) {
+        throw "FOUND NULL FUNCTION: $element";
+      } else {
+        return builder.buildProcedure(function);
+      }
+    } else if (element.isGenerativeConstructor) {
+      ir.Constructor constructor = kernel.functions[element];
+      if (constructor == null) {
+        throw "FOUND NULL CONSTRUCTOR: $element";
+      } else {
+        return builder.buildConstructor(constructor);
+      }
+    } else if (element.isField) {
+      ir.Field field = kernel.fields[element];
+      if (field == null) {
+        throw "FOUND NULL FIELD: $element";
+      } else {
+        return builder.buildField(field);
+      }
     } else {
-      return builder.buildProcedure(function);
+      throw new UnsupportedError("Unsupported element: $element");
     }
-  } else if (element.isGenerativeConstructor) {
-    ir.Constructor constructor = kernel.functions[element];
-    if (constructor == null) {
-      throw "FOUND NULL CONSTRUCTOR: $element";
-    } else {
-      return builder.buildConstructor(constructor);
-    }
-  } else if (element.isField) {
-    ir.Field field = kernel.fields[element];
-    if (field == null) {
-      throw "FOUND NULL FIELD: $element";
-    } else {
-      return builder.buildField(field);
-    }
-  } else {
-    throw new UnsupportedError("Unsupported element: $element");
-  }
+  });
 }
 
 class KernelImpactBuilder extends ir.Visitor {
   final ResolvedAst resolvedAst;
   final Compiler compiler;
 
   JavaScriptBackend get backend => compiler.backend;
 
   ResolutionWorldImpactBuilder impactBuilder;
   KernelAstAdapter astAdapter;
@@ skipping 28 matching lines @@
       checkType(node.returnType);
     }
     node.positionalParameters.forEach(handleParameter);
     node.namedParameters.forEach(handleParameter);
   }
 
   ResolutionImpact buildField(ir.Field field) {
     checkType(field.type);
     if (field.initializer != null) {
       visitNode(field.initializer);
-      if (!field.isConst) {
+      if (!field.isInstanceMember && !field.isConst) {
         impactBuilder.registerFeature(Feature.LAZY_FIELD);
       }
     } else {
       impactBuilder.registerFeature(Feature.FIELD_WITHOUT_INITIALIZER);
     }
     return impactBuilder;
   }
 
   ResolutionImpact buildConstructor(ir.Constructor constructor) {
     handleSignature(constructor.function, checkReturnType: false);
@@ skipping 165 matching lines @@
       //    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.
-      handleNew(node, node.target);
+      handleNew(node, node.target, isConst: node.isConst);
     } else {
       _visitArguments(node.arguments);
       impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
           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 {
       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));
   }
 
+  void handleSuperInvocation(ir.Node target, ir.Node arguments) {
+    Element element = astAdapter.getElement(target).declaration;
+    _visitArguments(arguments);
+    impactBuilder.registerStaticUse(new StaticUse.superInvoke(
+        element, astAdapter.getCallStructure(arguments)));
+  }
+
+  @override
+  void visitDirectMethodInvocation(ir.DirectMethodInvocation node) {
+    handleSuperInvocation(node.target, node.arguments);
+  }
+
+  @override
+  void visitSuperMethodInvocation(ir.SuperMethodInvocation node) {
+    // TODO(johnniwinther): Should we support this or always use the
+    // [MixinFullResolution] transformer?
+    handleSuperInvocation(node.interfaceTarget, node.arguments);
+  }
+
+  void handleSuperGet(ir.Member target) {
+    Element element = astAdapter.getElement(target).declaration;
+    if (target is ir.Procedure && target.kind == ir.ProcedureKind.Method) {
+      impactBuilder.registerStaticUse(new StaticUse.superTearOff(element));
+    } else {
+      impactBuilder.registerStaticUse(new StaticUse.superGet(element));
+    }
+  }
+
+  @override
+  void visitDirectGet(ir.StaticGet node) {
+    handleSuperGet(node.target);
+  }
+
+  @override
+  void visitSuperPropertyGet(ir.SuperPropertyGet node) {
+    handleSuperGet(node.interfaceTarget);
+  }
+
+  void handleSuperSet(ir.Node target, ir.Node value) {
+    visitNode(value);
+    Element element = astAdapter.getElement(target).declaration;
+    if (target is ir.Field) {
+      impactBuilder.registerStaticUse(new StaticUse.superFieldSet(element));
+    } else {
+      impactBuilder.registerStaticUse(new StaticUse.superSetterSet(element));
+    }
+  }
+
+  @override
+  void visitDirectPropertySet(ir.DirectPropertySet node) {
+    handleSuperSet(node.target, node.value);
+  }
+
+  @override
+  void visitSuperPropertySet(ir.SuperPropertySet node) {
+    handleSuperSet(node.interfaceTarget, node.value);
+  }
+
   @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(
@@ skipping 55 matching lines @@
       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)));
+    visitNode(node.operand);
   }
 
   @override
   void visitAsExpression(ir.AsExpression node) {
     impactBuilder
         .registerTypeUse(new TypeUse.asCast(astAdapter.getDartType(node.type)));
+    visitNode(node.operand);
   }
 
   @override
   void visitThrow(ir.Throw node) {
     impactBuilder.registerFeature(Feature.THROW_EXPRESSION);
     visitNode(node.expression);
   }
 
   @override
   void visitForInStatement(ir.ForInStatement node) {
@@ skipping 30 matching lines @@
     }
     visitNode(node.body);
   }
 
   @override
   void visitTryFinally(ir.TryFinally node) {
     visitNode(node.body);
     visitNode(node.finalizer);
   }
 
+  @override
+  void visitTypeLiteral(ir.TypeLiteral node) {
+    impactBuilder.registerTypeUse(
+        new TypeUse.typeLiteral(astAdapter.getDartType(node.type)));
+  }
+
+  @override
+  void visitFieldInitializer(ir.FieldInitializer node) {
+    impactBuilder.registerStaticUse(
+        new StaticUse.fieldInit(astAdapter.getElement(node.field)));
+    visitNode(node.value);
+  }
+
+  @override
+  void visitRedirectingInitializer(ir.RedirectingInitializer node) {
+    _visitArguments(node.arguments);
+    Element target = astAdapter.getElement(node.target).declaration;
+    impactBuilder.registerStaticUse(new StaticUse.superConstructorInvoke(
+        target, astAdapter.getCallStructure(node.arguments)));
+  }
+
   // 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);
 }