Clean up deferred checks in Kernel.

pkg/compiler/lib/src/kernel/kernel_visitor.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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
@@ skipping 1206 matching lines @@
   ir.InvocationExpression visitBoolFromEnvironmentConstructorInvoke(
       NewExpression node, BoolFromEnvironmentConstantExpression constant, _) {
     return buildConstructorInvoke(node, isConst: true);
   }
 
   ir.TypeLiteral buildTypeLiteral(TypeConstantExpression constant) {
     return new ir.TypeLiteral(kernel.typeLiteralToIr(constant));
   }
 
   @override
-  ir.TypeLiteral visitClassTypeLiteralGet(
+  ir.Expression visitClassTypeLiteralGet(
       Send node, ConstantExpression constant, _) {
-    return buildTypeLiteral(constant);
+    return _addCheckLibraryLoadedIfNeeded(buildTypeLiteral(constant));
   }
 
   @override
   ir.MethodInvocation visitClassTypeLiteralInvoke(
       Send node,
       ConstantExpression constant,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return associateNode(
@@ skipping 767 matching lines @@
   }
 
   @override
   visitStaticFieldDeclaration(VariableDefinitions node, Node definition,
       FieldElement field, Node initializer, _) {
     // Shouldn't be called, handled by fieldToIr.
     return internalError(node, "StaticFieldDeclaration");
   }
 
   ir.Expression buildStaticGet(Element element) {
-    var expression = buildStaticAccessor(element).buildSimpleRead();
-    if (_deferredLibrary != null) {
-      ir.Let let = new ir.Let(
-          makeOrReuseVariable(new ir.CheckLibraryIsLoaded(_deferredLibrary)),
-          expression);
-      return let;
-    }
-    return expression;
+    return _addCheckLibraryLoadedIfNeeded(
+        buildStaticAccessor(element).buildSimpleRead());
   }
 
   @override
   ir.Expression handleStaticFieldGet(Send node, FieldElement field, _) {
     return associateNode(buildStaticGet(field), node);
   }
 
   @override
   ir.MethodInvocation handleStaticFieldInvoke(Send node, FieldElement field,
       NodeList arguments, CallStructure callStructure, _) {
@@ skipping 672 matching lines @@
       FunctionExpression node, MethodElement getter, Node body, _) {
     return buildIrFunction(ir.ProcedureKind.Getter, getter, body);
   }
 
   @override
   IrFunction visitTopLevelSetterDeclaration(FunctionExpression node,
       MethodElement setter, NodeList parameters, Node body, _) {
     return buildIrFunction(ir.ProcedureKind.Setter, setter, body);
   }
 
-  @override
-  ir.TypeLiteral visitTypeVariableTypeLiteralGet(
-      Send node, TypeVariableElement element, _) {
-    return buildTypeVariable(element);
+  ir.Expression _addCheckLibraryLoadedIfNeeded(ir.Expression inputExpression) {
+    if (_deferredLibrary != null) {
+      ir.Let let = new ir.Let(
+          makeOrReuseVariable(new ir.CheckLibraryIsLoaded(_deferredLibrary)),
+          inputExpression);
+      // Only need to add this check once per statement, regardless of the
+      // number of expressions that access a deferred member.

[sra1, 2017/02/15 23:55:31]

consider:

  prefix1.foo(prefix2.a, prefix3.b)

does this check the prefixes in the right order?

[Emily Fortuna, 2017/02/16 02:21:56]

yes.

+      _deferredLibrary = null;
+      return let;
+    }
+    return inputExpression;
   }
 
   @override
+  ir.Expression visitTypeVariableTypeLiteralGet(
+      Send node, TypeVariableElement element, _) {
+    return _addCheckLibraryLoadedIfNeeded(buildTypeVariable(element));
+  }
+
+  @override
   ir.MethodInvocation visitTypeVariableTypeLiteralInvoke(
       Send node,
       TypeVariableElement element,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return associateNode(
         buildCall(buildTypeVariable(element), callStructure, arguments), node);
   }
 
   @override
   ir.Expression visitTypeVariableTypeLiteralSet(
       SendSet node, TypeVariableElement element, Node rhs, _) {
     return new ReadOnlyAccessor(buildTypeVariable(element))
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitTypeVariableTypeLiteralSetIfNull(
       Send node, TypeVariableElement element, Node rhs, _) {
     return _finishSetIfNull(
         node, new ReadOnlyAccessor(buildTypeVariable(element)), rhs);
   }
 
   @override
-  ir.TypeLiteral visitTypedefTypeLiteralGet(
+  ir.Expression visitTypedefTypeLiteralGet(
       Send node, ConstantExpression constant, _) {
-    return buildTypeLiteral(constant);
+    return _addCheckLibraryLoadedIfNeeded(buildTypeLiteral(constant));
   }
 
   @override
   ir.MethodInvocation visitTypedefTypeLiteralInvoke(
       Send node,
       ConstantExpression constant,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return associateNode(
@@ skipping 144 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }