Search html extension types lazily

lib/src/codegen/js_codegen.dart

 // Copyright (c) 2015, 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 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
@@ skipping 45 matching lines @@
 const DSEND = 'dsend';
 
 class JSCodegenVisitor extends GeneralizingAstVisitor
     with ClosureAnnotator, JsTypeRefCodegen {
   final AbstractCompiler compiler;
   final CodegenOptions options;
   final LibraryElement currentLibrary;
   final StrongTypeSystemImpl rules;
 
   /// The global extension type table.
-  final HashSet<ClassElement> _extensionTypes;
+  final ExtensionTypeSet _extensionTypes;
 
   /// Information that is precomputed for this library, indicates which fields
   /// need storage slots.
   final HashSet<FieldElement> _fieldsNeedingStorage;
 
   /// The variable for the target of the current `..` cascade expression.
   ///
   /// Usually a [SimpleIdentifier], but it can also be other expressions
   /// that are safe to evaluate multiple times, such as `this`.
   Expression _cascadeTarget;
@@ skipping 3632 matching lines @@
     } else if (type is InterfaceType && type.element == expectedType.element) {
       return type.typeArguments[0];
     } else {
       // TODO(leafp): The above only handles the case where the return type
       // is exactly Future/Stream/Iterable.  Handle the subtype case.
       return DynamicTypeImpl.instance;
     }
   }
 }
 
-class _ExtensionFinder extends GeneralizingElementVisitor {
+class ExtensionTypeSet extends GeneralizingElementVisitor {
   final AnalysisContext _context;
-  final HashSet<ClassElement> _extensionTypes;
   final TypeProvider _types;
 
-  _ExtensionFinder(this._context, this._extensionTypes, this._types);
+  final _extensionTypes = new HashSet<ClassElement>();
+  final _pendingLibraries = new HashSet<String>();
+
+  ExtensionTypeSet(AbstractCompiler compiler)
+      : _context = compiler.context,
+        _types = compiler.context.typeProvider;
 
   visitClassElement(ClassElement element) {
     if (findAnnotation(element, isJsPeerInterface) != null ||
         findAnnotation(element, isNativeAnnotation) != null) {
       _addExtensionType(element.type);
     }
   }
 
   void _addExtensionType(InterfaceType t) {
     if (t.isObject || !_extensionTypes.add(t.element)) return;
     t = fillDynamicTypeArgs(t, _types) as InterfaceType;
     t.interfaces.forEach(_addExtensionType);
     t.mixins.forEach(_addExtensionType);
     _addExtensionType(t.superclass);
   }
 
+  void _addExtensionTypesForLibrary(String libraryUri, List<String> typeNames) {
+    var sourceFactory = _context.sourceFactory.forUri(libraryUri);
+    var library = _context.computeLibraryElement(sourceFactory);
+    for (var typeName in typeNames) {
+      var element = library.getType(typeName);
+      _addExtensionType(element.type);
+    }
+  }
+
   void _addExtensionTypes(String libraryUri) {
     var sourceFactory = _context.sourceFactory.forUri(libraryUri);
     var library = _context.computeLibraryElement(sourceFactory);
     visitLibraryElement(library);
   }
+
+  void _addPendingExtensionTypes(String libraryUri) {
+    _pendingLibraries.add(libraryUri);
+  }
+
+  bool contains(Element element) {
+    if (_extensionTypes.contains(element)) return true;
+    if (_pendingLibraries.isEmpty) return false;
+    if (element is ClassElement) {
+      var uri = element.library.source.uri.toString();
+      if (_pendingLibraries.contains(uri)) {
+        // Load all pending libraries
+        for (var libraryUri in _pendingLibraries) {
+          _addExtensionTypes(libraryUri);
+        }
+        _pendingLibraries.clear();
+        return _extensionTypes.contains(element);
+      }
+    }
+    return false;
+  }
 }
 
 class JSGenerator extends CodeGenerator {
-  final _extensionTypes = new HashSet<ClassElement>();
+  final ExtensionTypeSet _extensionTypes;
   final TypeProvider _types;
 
   JSGenerator(AbstractCompiler compiler)
       : _types = compiler.context.typeProvider,
+        _extensionTypes = new ExtensionTypeSet(compiler),
         super(compiler) {
     // TODO(vsm): Eventually, we want to make this extensible - i.e., find
     // annotations in user code as well.  It would need to be summarized in
-    // the element model - not searched this way on every compile.
-    var finder = new _ExtensionFinder(context, _extensionTypes, _types);
-    finder._addExtensionTypes('dart:_interceptors');
-    finder._addExtensionTypes('dart:_native_typed_data');
-    finder._addExtensionTypes('dart:html');
-    finder._addExtensionTypes('dart:indexed_db');
-    finder._addExtensionTypes('dart:svg');
-    finder._addExtensionTypes('dart:web_audio');
-    finder._addExtensionTypes('dart:web_gl');
-    finder._addExtensionTypes('dart:web_sql');
+    // the element model - not searched this way on every compile.  To make this
+    // a little more efficient now, we do this in two phases.
 
+    // First, core types:
+    _extensionTypes._addExtensionTypes('dart:_interceptors');
+    _extensionTypes._addExtensionTypes('dart:_native_typed_data');
     // TODO(vsm): If we're analyzing against the main SDK, those
     // types are not explicitly annotated.
-    finder._addExtensionType(_types.intType);
-    finder._addExtensionType(_types.doubleType);
-    finder._addExtensionType(_types.boolType);
-    finder._addExtensionType(_types.stringType);
+    _extensionTypes._addExtensionType(_types.intType);
+    _extensionTypes._addExtensionType(_types.doubleType);
+    _extensionTypes._addExtensionType(_types.boolType);
+    _extensionTypes._addExtensionType(_types.stringType);
+    // These are used natively by dart:html but also not annotated.
+    _extensionTypes
+        ._addExtensionTypesForLibrary('dart:core', ['Comparable', 'Map']);
+    _extensionTypes
+        ._addExtensionTypesForLibrary('dart:collection', ['ListMixin']);
+    _extensionTypes._addExtensionTypesForLibrary('dart:math', ['Rectangle']);
+
+    // Second, html types - these are only searched if we use dart:html, etc.:
+    _extensionTypes._addPendingExtensionTypes('dart:html');
+    _extensionTypes._addPendingExtensionTypes('dart:indexed_db');
+    _extensionTypes._addPendingExtensionTypes('dart:svg');
+    _extensionTypes._addPendingExtensionTypes('dart:web_audio');
+    _extensionTypes._addPendingExtensionTypes('dart:web_gl');
+    _extensionTypes._addPendingExtensionTypes('dart:web_sql');
   }
 
   String generateLibrary(LibraryUnit unit) {
     // Clone the AST first, so we can mutate it.
     unit = unit.clone();
     var library = unit.library.element.library;
     var fields = findFieldsNeedingStorage(unit, _extensionTypes);
     var rules = new StrongTypeSystemImpl();
     var codegen =
         new JSCodegenVisitor(compiler, rules, library, _extensionTypes, fields);
@@ skipping 27 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }