Handle signature types and fields 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 '../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_visitor.dart';
 import '../resolution/registry.dart' show ResolutionWorldImpactBuilder;
 import '../universe/feature.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;
   JavaScriptBackend backend = compiler.backend;
   Kernel kernel = backend.kernelTask.kernel;
-  ir.Procedure function = kernel.functions[element];
-  if (function == null) {
-    print("FOUND NULL FUNCTION: $element");
-    print(kernel.functions);
+  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);
+    }
+  } else {
+    ir.Field field = kernel.fields[element];
+    if (field == null) {
+      print("FOUND NULL FUNCTION: $element");
+    } else {
+      return builder.buildField(field);
+    }
   }
-  KernelImpactBuilder builder =
-      new KernelImpactBuilder(function, element, resolvedAst, compiler, kernel);
-  return builder.build();
+  return null;
 }
 
 class KernelImpactBuilder extends ir.Visitor {
-  final ir.Procedure function;
-  final FunctionElement functionElement;
   final ResolvedAst resolvedAst;
   final Compiler compiler;
 
   JavaScriptBackend get backend => compiler.backend;
 
   ResolutionWorldImpactBuilder impactBuilder;
   KernelAstAdapter astAdapter;
 
-  KernelImpactBuilder(this.function, this.functionElement, this.resolvedAst,
-      this.compiler, Kernel kernel) {
-    this.impactBuilder = new ResolutionWorldImpactBuilder('$functionElement');
+  KernelImpactBuilder(this.resolvedAst, this.compiler, Kernel kernel) {
+    this.impactBuilder =
+        new ResolutionWorldImpactBuilder('${resolvedAst.element}');
     this.astAdapter = new KernelAstAdapter(
         compiler.backend,
         resolvedAst,
         kernel.nodeToAst,
         kernel.nodeToElement,
         kernel.functions,
+        kernel.fields,
         kernel.classes,
         kernel.libraries);
   }
 
-  ResolutionImpact build() {
-    if (function.kind == ir.ProcedureKind.Method ||
-        function.kind == ir.ProcedureKind.Operator) {
-      buildMethod(function);
-    } else {
-      compiler.reporter.internalError(
-          functionElement,
-          "Unable to compute resolution impact for this kind of Kernel "
-          "procedure: ${function.kind}");
-    }
-    return impactBuilder;
-  }
-
   /// Add a checked-mode type use of [type] if it is not `dynamic`.
-  DartType checkType(DartType type) {
+  DartType checkType(ir.DartType irType) {
+    DartType type = astAdapter.getDartType(irType);
     if (!type.isDynamic) {
       impactBuilder.registerTypeUse(new TypeUse.checkedModeCheck(type));
     }
     return type;
   }
 
-  void buildMethod(ir.Procedure method) {
-    method.function.body.accept(this);
+  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));
+      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 visitNodes(Iterable<ir.Node> nodes) {
     nodes.forEach((ir.Node node) => node.accept(this));
   }
 
   @override
   void visitBlock(ir.Block block) => visitNodes(block.statements);
 
   @override
@@ skipping 43 matching lines @@
   }
 
   @override
   void visitNullLiteral(ir.NullLiteral literal) {
     impactBuilder.registerConstantLiteral(new NullConstantExpression());
   }
 
   @override
   void visitListLiteral(ir.ListLiteral literal) {
     visitNodes(literal.expressions);
-    DartType elementType =
-        checkType(astAdapter.getDartType(literal.typeArgument));
+    DartType elementType = checkType(literal.typeArgument);
 
     impactBuilder.registerListLiteral(new ListLiteralUse(
         compiler.coreTypes.listType(elementType),
         isConstant: literal.isConst,
         isEmpty: literal.expressions.isEmpty));
   }
 
   @override
   void visitMapLiteral(ir.MapLiteral literal) {
     visitNodes(literal.entries);
-    DartType keyType = checkType(astAdapter.getDartType(literal.keyType));
-    DartType valueType = checkType(astAdapter.getDartType(literal.valueType));
+    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);
   }
 
   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);
     }
   }
 
   @override
   void visitStaticInvocation(ir.StaticInvocation invocation) {
     _visitArguments(invocation.arguments);
     Element target = astAdapter.getElement(invocation.target).declaration;
     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));
+  }
+
+  @override
   void visitMethodInvocation(ir.MethodInvocation invocation) {
     invocation.receiver.accept(this);
     _visitArguments(invocation.arguments);
     impactBuilder.registerDynamicUse(
         new DynamicUse(astAdapter.getSelector(invocation), null));
   }
 
   @override
   void visitNot(ir.Not not) {
     not.operand.accept(this);
   }
 }