Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(691)

Unified Diff: pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart

Issue 693183006: Revert "Move dart2js from sdk/lib/_internal/compiler to pkg/compiler" (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 6 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart
diff --git a/pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart b/pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart
deleted file mode 100644
index 9a5c8e987940a9ec62bb27bc9291ab808012f7ee..0000000000000000000000000000000000000000
--- a/pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart
+++ /dev/null
@@ -1,207 +0,0 @@
-// Copyright (c) 2013, 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.
-
-part of js_backend;
-
-/**
- * Support for Custom Elements.
- *
- * The support for custom elements the compiler builds a table that maps the
- * custom element class's [Type] to the interceptor for the class and the
- * constructor(s) for the class.
- *
- * We want the table to contain only the custom element classes used, and we
- * want to avoid resolving and compiling constructors that are not used since
- * that may bring in unused code. This class controls the resolution and code
- * generation to restrict the impact.
- *
- * The following line of code requires the generation of the generative
- * constructor factory function(s) for FancyButton, and their insertion into the
- * table:
- *
- * document.register(FancyButton, 'x-fancy-button');
- *
- * We detect this by 'joining' the classes that are referenced as type literals
- * with the classes that are custom elements, enabled by detecting the presence
- * of the table access code used by document.register.
- *
- * We have to be more conservative when the type is unknown, e.g.
- *
- * document.register(classMirror.reflectedType, tagFromMetadata);
- *
- * and
- *
- * class Component<T> {
- * final tag;
- * Component(this.tag);
- * void register() => document.register(T, tag);
- * }
- * const Component<FancyButton>('x-fancy-button').register();
- *
- * In these cases we conservatively generate all viable entries in the table.
- */
-class CustomElementsAnalysis {
- final JavaScriptBackend backend;
- final Compiler compiler;
- final CustomElementsAnalysisJoin resolutionJoin;
- final CustomElementsAnalysisJoin codegenJoin;
- bool fetchedTableAccessorMethod = false;
- Element tableAccessorMethod;
-
- CustomElementsAnalysis(JavaScriptBackend backend)
- : this.backend = backend,
- this.compiler = backend.compiler,
- resolutionJoin = new CustomElementsAnalysisJoin(backend),
- codegenJoin = new CustomElementsAnalysisJoin(backend) {
- // TODO(sra): Remove this work-around. We should mark allClassesSelected in
- // both joins only when we see a construct generating an unknown [Type] but
- // we can't currently recognize all cases. In particular, the work-around
- // for the unimplemented `ClassMirror.reflectedType` is not recognizable.
- // TODO(12607): Match on [ClassMirror.reflectedType]
- resolutionJoin.allClassesSelected = true;
- codegenJoin.allClassesSelected = true;
- }
-
- CustomElementsAnalysisJoin joinFor(Enqueuer enqueuer) =>
- enqueuer.isResolutionQueue ? resolutionJoin : codegenJoin;
-
- void registerInstantiatedClass(ClassElement classElement, Enqueuer enqueuer) {
- classElement.ensureResolved(compiler);
- if (!Elements.isNativeOrExtendsNative(classElement)) return;
- if (classElement.isMixinApplication) return;
- if (classElement.isAbstract) return;
- joinFor(enqueuer).instantiatedClasses.add(classElement);
- }
-
- void registerTypeLiteral(DartType type, Registry registry) {
- assert(registry.isForResolution);
- // In codegen we see the TypeConstants instead.
- if (!registry.isForResolution) return;
-
- if (type.isInterfaceType) {
- // TODO(sra): If we had a flow query from the type literal expression to
- // the Type argument of the metadata lookup, we could tell if this type
- // literal is really a demand for the metadata.
- resolutionJoin.selectedClasses.add(type.element);
- } else if (type.isTypeVariable) {
- // This is a type parameter of a parameterized class.
- // TODO(sra): Is there a way to determine which types are bound to the
- // parameter?
- resolutionJoin.allClassesSelected = true;
- }
- }
-
- void registerTypeConstant(Element element, Enqueuer enqueuer) {
- assert(element.isClass);
- assert(!enqueuer.isResolutionQueue);
- codegenJoin.selectedClasses.add(element);
- }
-
- void registerStaticUse(Element element, Enqueuer enqueuer) {
- assert(element != null);
- if (!fetchedTableAccessorMethod) {
- fetchedTableAccessorMethod = true;
- tableAccessorMethod = backend.findInterceptor(
- 'findIndexForNativeSubclassType');
- }
- if (element == tableAccessorMethod) {
- joinFor(enqueuer).demanded = true;
- }
- }
-
- void onQueueEmpty(Enqueuer enqueuer) {
- joinFor(enqueuer).flush(enqueuer);
- }
-
- bool get needsTable => codegenJoin.demanded;
-
- bool needsClass(ClassElement classElement) =>
- codegenJoin.activeClasses.contains(classElement);
-
- List<Element> constructors(ClassElement classElement) =>
- codegenJoin.computeEscapingConstructors(classElement);
-}
-
-
-class CustomElementsAnalysisJoin {
- final JavaScriptBackend backend;
- Compiler get compiler => backend.compiler;
-
- // Classes that are candidates for needing constructors. Classes are moved to
- // [activeClasses] when we know they need constructors.
- final instantiatedClasses = new Set<ClassElement>();
-
- // Classes explicitly named.
- final selectedClasses = new Set<ClassElement>();
-
- // True if we must conservatively include all extension classes.
- bool allClassesSelected = false;
-
- // Did we see a demand for the data?
- bool demanded = false;
-
- // ClassesOutput: classes requiring metadata.
- final activeClasses = new Set<ClassElement>();
-
- CustomElementsAnalysisJoin(this.backend);
-
- void flush(Enqueuer enqueuer) {
- if (!demanded) return;
- var newActiveClasses = new Set<ClassElement>();
- for (ClassElement classElement in instantiatedClasses) {
- bool isNative = classElement.isNative;
- bool isExtension =
- !isNative && Elements.isNativeOrExtendsNative(classElement);
- // Generate table entries for native classes that are explicitly named and
- // extensions that fix our criteria.
- if ((isNative && selectedClasses.contains(classElement)) ||
- (isExtension &&
- (allClassesSelected || selectedClasses.contains(classElement)))) {
- newActiveClasses.add(classElement);
- Iterable<Element> escapingConstructors =
- computeEscapingConstructors(classElement);
- escapingConstructors.forEach(enqueuer.registerStaticUse);
- escapingConstructors
- .forEach(compiler.globalDependencies.registerDependency);
- // Force the generaton of the type constant that is the key to an entry
- // in the generated table.
- ConstantValue constant = makeTypeConstant(classElement);
- backend.registerCompileTimeConstant(
- constant, compiler.globalDependencies);
- backend.constants.addCompileTimeConstantForEmission(constant);
- }
- }
- activeClasses.addAll(newActiveClasses);
- instantiatedClasses.removeAll(newActiveClasses);
- }
-
- TypeConstantValue makeTypeConstant(ClassElement element) {
- DartType elementType = element.rawType;
- DartType constantType = backend.typeImplementation.rawType;
- return new TypeConstantValue(elementType, constantType);
- }
-
- List<Element> computeEscapingConstructors(ClassElement classElement) {
- List<Element> result = <Element>[];
- // Only classes that extend native classes have constructors in the table.
- // We could refine this to classes that extend Element, but that would break
- // the tests and there is no sane reason to subclass other native classes.
- if (classElement.isNative) return result;
-
- selectGenerativeConstructors(ClassElement enclosing, Element member) {
- if (member.isGenerativeConstructor) {
- // Ignore constructors that cannot be called with zero arguments.
- FunctionElement constructor = member;
- FunctionSignature parameters = constructor.functionSignature;
- if (parameters.requiredParameterCount == 0) {
- result.add(member);
- }
- }
- }
- classElement.forEachMember(selectGenerativeConstructors,
- includeBackendMembers: false,
- includeSuperAndInjectedMembers: false);
- return result;
- }
-}
« no previous file with comments | « pkg/compiler/lib/src/js_backend/constant_system_javascript.dart ('k') | pkg/compiler/lib/src/js_backend/js_backend.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698