Build entire program with kernel for conversion to ssa.

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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/values.dart';
 import '../dart_types.dart';
@@ skipping 16 matching lines @@
   final ResolvedAst _resolvedAst;
   final Map<ir.Node, ast.Node> _nodeToAst;
   final Map<ir.Node, Element> _nodeToElement;
   DartTypeConverter _typeConverter;
 
   KernelAstAdapter(
       this._backend,
       this._resolvedAst,
       this._nodeToAst,
       this._nodeToElement,
+      Map<FieldElement, ir.Field> fields,
       Map<FunctionElement, ir.Member> functions,
       Map<ClassElement, ir.Class> classes,
       Map<LibraryElement, ir.Library> libraries) {
+    // TODO(het): Maybe just use all of the kernel maps directly?
+    for (FieldElement fieldElement in fields.keys) {
+      _nodeToElement[fields[fieldElement]] = fieldElement;
+    }
     for (FunctionElement functionElement in functions.keys) {
       _nodeToElement[functions[functionElement]] = functionElement;
     }
     for (ClassElement classElement in classes.keys) {
       _nodeToElement[classes[classElement]] = classElement;
     }
     for (LibraryElement libraryElement in libraries.keys) {
       _nodeToElement[libraries[libraryElement]] = libraryElement;
     }
     _typeConverter = new DartTypeConverter(this);
@@ skipping 16 matching lines @@
     assert(result != null);
     return result;
   }
 
   ast.Node getNode(ir.Node node) {
     ast.Node result = _nodeToAst[node];
     assert(result != null);
     return result;
   }
 
-  bool getCanThrow(ir.Procedure procedure) {
-    FunctionElement function = getElement(procedure);
-    return !_compiler.world.getCannotThrow(function);
+  bool getCanThrow(ir.Node procedure) {
+    return !_compiler.world.getCannotThrow(getElement(procedure));
   }
 
-  TypeMask returnTypeOf(ir.Procedure node) {
+  TypeMask returnTypeOf(ir.Member node) {
     return TypeMaskFactory.inferredReturnTypeForElement(
         getElement(node), _compiler);
   }
 
   SideEffects getSideEffects(ir.Node node) {
     return _compiler.world.getSideEffectsOfElement(getElement(node));
   }
 
   CallStructure getCallStructure(ir.Arguments arguments) {
     int argumentCount = arguments.positional.length + arguments.named.length;
     List<String> namedArguments = arguments.named.map((e) => e.name).toList();
     return new CallStructure(argumentCount, namedArguments);
   }
 
   // TODO(het): Create the selector directly from the invocation
-  Selector getSelector(ir.MethodInvocation invocation) {
+  Selector getSelector(ir.InvocationExpression invocation) {
     SelectorKind kind = Elements.isOperatorName(invocation.name.name)
         ? SelectorKind.OPERATOR
         : SelectorKind.CALL;
+    if (invocation.name.name == '[]' || invocation.name.name == '[]=') {
+      kind = SelectorKind.INDEX;
+    }
 
     ir.Name irName = invocation.name;
     Name name = new Name(
         irName.name, irName.isPrivate ? getElement(irName.library) : null);
     CallStructure callStructure = getCallStructure(invocation.arguments);
 
     return new Selector(kind, name, callStructure);
   }
 
+  Selector getGetterSelector(ir.PropertyGet getter) {
+    ir.Name irName = getter.name;
+    Name name = new Name(
+        irName.name, irName.isPrivate ? getElement(irName.library) : null);
+    return new Selector.getter(name);
+  }
+
   TypeMask typeOfInvocation(ir.MethodInvocation invocation) {
     return _compiler.globalInference.results
         .typeOfSend(getNode(invocation), _elements);
   }
 
+  TypeMask typeOfGet(ir.PropertyGet getter) {
+    return _compiler.globalInference.results
+        .typeOfSend(getNode(getter), _elements);
+  }
+
+  TypeMask inferredTypeOf(ir.Member node) {
+    return TypeMaskFactory.inferredTypeForElement(getElement(node), _compiler);
+  }
+
   TypeMask selectorTypeOf(ir.MethodInvocation invocation) {
     return TypeMaskFactory.inferredTypeForSelector(
         getSelector(invocation), typeOfInvocation(invocation), _compiler);
   }
 
-  bool isIntercepted(ir.MethodInvocation invocation) {
-    return _backend.isInterceptedSelector(getSelector(invocation));
+  TypeMask selectorGetterTypeOf(ir.PropertyGet getter) {
+    return TypeMaskFactory.inferredTypeForSelector(
+        getGetterSelector(getter), typeOfGet(getter), _compiler);
+  }
+
+  bool isIntercepted(ir.Node node) {
+    Selector selector;
+    if (node is ir.PropertyGet) {
+      selector = getGetterSelector(node);
+    } else {
+      selector = getSelector(node);
+    }
+    return _backend.isInterceptedSelector(selector);
   }
 
   DartType getDartType(ir.DartType type) {
     return type.accept(_typeConverter);
   }
 }
 
 class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
   final KernelAstAdapter astAdapter;
 
@@ skipping 28 matching lines @@
   @override
   DartType visitDynamicType(ir.DynamicType node) {
     return const DynamicType();
   }
 
   @override
   DartType visitInvalidType(ir.InvalidType node) {
     throw new UnimplementedError("Invalid types not currently supported");
   }
 }