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);
+    var loadedCheckFunc =
+        _createCheckLibraryLoadedFuncIfNeeded(_deferredLibrary);
+    _deferredLibrary = null;
+    return loadedCheckFunc(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;
+    var loadedCheckFunc =
+        _createCheckLibraryLoadedFuncIfNeeded(_deferredLibrary);
+    _deferredLibrary = null;
+    return loadedCheckFunc(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 191 matching lines @@
 
   ir.StaticInvocation buildStaticInvoke(
       FunctionElement function, NodeList arguments,
       {bool isConst}) {
     ir.Arguments argumentsNode = buildArguments(arguments);
     return new ir.StaticInvocation(kernel.functionToIr(function), argumentsNode,
         isConst: isConst);
   }
 
   @override
-  ir.StaticInvocation handleStaticFunctionInvoke(
-      Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
-      _) {
-    return associateNode(
-        buildStaticInvoke(function, arguments, isConst: false), node);
+  ir.Expression handleStaticFunctionInvoke(Send node, MethodElement function,
+      NodeList arguments, CallStructure callStructure, _) {
+    var loadedCheckFunc =
+        _createCheckLibraryLoadedFuncIfNeeded(_deferredLibrary);
+    _deferredLibrary = null;
+    return loadedCheckFunc(associateNode(
+        buildStaticInvoke(function, arguments, isConst: false), node));
   }
 
   @override
   ir.Expression handleStaticFunctionSet(
       Send node, MethodElement function, Node rhs, _) {
     return buildStaticAccessor(function)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
@@ skipping 453 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);
+  /// Return a function that accepts an expression and returns an expression. If
+  /// deferredImport is null, then the function returned is the identity
+  /// expression. Otherwise, it inserts a CheckLibraryIsLoaded call before
+  /// evaluating the expression.
+  _createCheckLibraryLoadedFuncIfNeeded(ir.DeferredImport deferredImport) {
+    if (deferredImport != null) {
+      return (ir.Expression inputExpression) => new ir.Let(
+          makeOrReuseVariable(new ir.CheckLibraryIsLoaded(deferredImport)),
+          inputExpression);
+    } else {
+      return (ir.Expression expr) => expr;
+    }
   }
 
   @override
+  ir.Expression visitTypeVariableTypeLiteralGet(
+      Send node, TypeVariableElement element, _) {
+    var loadedCheckFunc =
+        _createCheckLibraryLoadedFuncIfNeeded(_deferredLibrary);
+    _deferredLibrary = null;
+    return loadedCheckFunc(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);
+    var loadedCheckFunc =
+        _createCheckLibraryLoadedFuncIfNeeded(_deferredLibrary);
+    _deferredLibrary = null;
+    return loadedCheckFunc(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)";
   }
 }