Index: pkg/compiler/lib/src/dart_backend/backend.dart |
diff --git a/pkg/compiler/lib/src/dart_backend/backend.dart b/pkg/compiler/lib/src/dart_backend/backend.dart |
deleted file mode 100644 |
index c9d69aeb74244d61af08ad51d96682fd2ced14cd..0000000000000000000000000000000000000000 |
--- a/pkg/compiler/lib/src/dart_backend/backend.dart |
+++ /dev/null |
@@ -1,546 +0,0 @@ |
-// Copyright (c) 2012, 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 dart_backend; |
- |
-// TODO(ahe): This class is simply wrong. This backend should use |
-// elements when it can, not AST nodes. Perhaps a [Map<Element, |
-// TreeElements>] is what is needed. |
-class ElementAst { |
- final Node ast; |
- final TreeElements treeElements; |
- |
- ElementAst(this.ast, this.treeElements); |
-} |
- |
-class DartBackend extends Backend { |
- final List<CompilerTask> tasks; |
- final bool stripAsserts; |
- |
- bool get supportsReflection => true; |
- |
- // TODO(zarah) Maybe change this to a command-line option. |
- // Right now, it is set by the tests. |
- bool useMirrorHelperLibrary = false; |
- |
- /// Updated to a [MirrorRenamerImpl] instance if the [useMirrorHelperLibrary] |
- /// field is set and mirror are needed. |
- MirrorRenamer mirrorRenamer = const MirrorRenamer(); |
- |
- final DartOutputter outputter; |
- |
- // Used in test. |
- PlaceholderRenamer get placeholderRenamer => outputter.renamer; |
- Map<ClassNode, List<Node>> get memberNodes => outputter.output.memberNodes; |
- |
- ConstantSystem get constantSystem { |
- return constantCompilerTask.constantCompiler.constantSystem; |
- } |
- |
- BackendConstantEnvironment get constants => constantCompilerTask; |
- |
- DartConstantTask constantCompilerTask; |
- |
- DartImpactTransformer impactTransformer; |
- |
- final Set<ClassElement> usedTypeLiterals = new Set<ClassElement>(); |
- |
- /// The set of visible platform classes that are implemented by instantiated |
- /// user classes. |
- final Set<ClassElement> _userImplementedPlatformClasses = |
- new Set<ClassElement>(); |
- |
- bool enableCodegenWithErrorsIfSupported(Spannable node) { |
- reporter.reportHintMessage(node, MessageKind.GENERIC, { |
- 'text': "Generation of code with compile time errors is not " |
- "supported for dart2dart." |
- }); |
- return false; |
- } |
- |
- /** |
- * Tells whether it is safe to remove type declarations from variables, |
- * functions parameters. It becomes not safe if: |
- * 1) TypeError is used somewhere in the code, |
- * 2) The code has typedefs in right hand side of IS checks, |
- * 3) The code has classes which extend typedefs, have type arguments typedefs |
- * or type variable bounds typedefs. |
- * These restrictions can be less strict. |
- */ |
- bool isSafeToRemoveTypeDeclarations( |
- Map<ClassElement, Iterable<Element>> classMembers) { |
- ClassElement typeErrorElement = compiler.coreLibrary.find('TypeError'); |
- if (classMembers.containsKey(typeErrorElement) || |
- compiler.resolverWorld.isChecks |
- .any((DartType type) => type.element == typeErrorElement)) { |
- return false; |
- } |
- Set<DartType> processedTypes = new Set<DartType>(); |
- List<DartType> workQueue = new List<DartType>(); |
- workQueue |
- .addAll(classMembers.keys.map((classElement) => classElement.thisType)); |
- workQueue.addAll(compiler.resolverWorld.isChecks); |
- |
- while (!workQueue.isEmpty) { |
- DartType type = workQueue.removeLast(); |
- if (processedTypes.contains(type)) continue; |
- processedTypes.add(type); |
- if (type is FunctionType) return false; |
- if (type is TypedefType) return false; |
- if (type is InterfaceType) { |
- InterfaceType interfaceType = type; |
- // Check all type arguments. |
- interfaceType.typeArguments.forEach(workQueue.add); |
- ClassElement element = type.element; |
- // Check all supertypes. |
- if (element.allSupertypes != null) { |
- element.allSupertypes.forEach(workQueue.add); |
- } |
- } |
- } |
- return true; |
- } |
- |
- DartBackend(Compiler compiler, List<String> strips, {bool multiFile}) |
- : tasks = <CompilerTask>[], |
- stripAsserts = strips.indexOf('asserts') != -1, |
- constantCompilerTask = new DartConstantTask(compiler), |
- outputter = new DartOutputter( |
- compiler.reporter, compiler.outputProvider, |
- forceStripTypes: strips.indexOf('types') != -1, |
- multiFile: multiFile, |
- enableMinification: compiler.options.enableMinification), |
- super(compiler) { |
- impactTransformer = new DartImpactTransformer(this); |
- } |
- |
- DiagnosticReporter get reporter => compiler.reporter; |
- |
- Resolution get resolution => compiler.resolution; |
- |
- bool classNeedsRti(ClassElement cls) => false; |
- bool methodNeedsRti(FunctionElement function) => false; |
- |
- void enqueueHelpers(ResolutionEnqueuer world, Registry registry) { |
- // Right now resolver doesn't always resolve interfaces needed |
- // for literals, so force them. TODO(antonm): fix in the resolver. |
- final LITERAL_TYPE_NAMES = const [ |
- 'Map', |
- 'List', |
- 'num', |
- 'int', |
- 'double', |
- 'bool' |
- ]; |
- final coreLibrary = compiler.coreLibrary; |
- for (final name in LITERAL_TYPE_NAMES) { |
- ClassElement classElement = coreLibrary.findLocal(name); |
- classElement.ensureResolved(resolution); |
- } |
- // Enqueue the methods that the VM might invoke on user objects because |
- // we don't trust the resolution to always get these included. |
- world.registerDynamicUse(new DynamicUse(Selectors.toString_, null)); |
- world.registerDynamicUse(new DynamicUse(Selectors.hashCode_, null)); |
- world.registerDynamicUse( |
- new DynamicUse(new Selector.binaryOperator('=='), null)); |
- world.registerDynamicUse(new DynamicUse(Selectors.compareTo, null)); |
- } |
- |
- WorldImpact codegen(CodegenWorkItem work) { |
- return const WorldImpact(); |
- } |
- |
- /** |
- * Tells whether we should output given element. Corelib classes like |
- * Object should not be in the resulting code. |
- */ |
- @override |
- bool shouldOutput(Element element) { |
- return (!element.library.isPlatformLibrary && |
- !element.isSynthesized && |
- element is! AbstractFieldElement) || |
- mirrorRenamer.isMirrorHelperLibrary(element.library); |
- } |
- |
- int assembleProgram() { |
- ElementAst computeElementAst(AstElement element) { |
- return new ElementAst( |
- element.resolvedAst.node, element.resolvedAst.elements); |
- } |
- |
- // TODO(johnniwinther): Remove the need for this method. |
- void postProcessElementAst(AstElement element, ElementAst elementAst, |
- newTypedefElementCallback, newClassElementCallback) { |
- ReferencedElementCollector collector = new ReferencedElementCollector( |
- reporter, |
- element, |
- elementAst, |
- newTypedefElementCallback, |
- newClassElementCallback); |
- collector.collect(); |
- } |
- |
- int totalSize = outputter.assembleProgram( |
- libraries: compiler.libraryLoader.libraries, |
- instantiatedClasses: compiler.resolverWorld.directlyInstantiatedClasses, |
- resolvedElements: compiler.enqueuer.resolution.processedElements, |
- usedTypeLiterals: usedTypeLiterals, |
- postProcessElementAst: postProcessElementAst, |
- computeElementAst: computeElementAst, |
- shouldOutput: shouldOutput, |
- isSafeToRemoveTypeDeclarations: isSafeToRemoveTypeDeclarations, |
- sortElements: Elements.sortedByPosition, |
- mirrorRenamer: mirrorRenamer, |
- mainFunction: compiler.mainFunction, |
- outputUri: compiler.options.outputUri); |
- |
- // Output verbose info about size ratio of resulting bundle to all |
- // referenced non-platform sources. |
- logResultBundleSizeInfo(outputter.libraryInfo.userLibraries, |
- outputter.elementInfo.topLevelElements, totalSize); |
- |
- return totalSize; |
- } |
- |
- void logResultBundleSizeInfo(Iterable<LibraryElement> userLibraries, |
- Iterable<Element> topLevelElements, int totalOutputSize) { |
- // Sum total size of scripts in each referenced library. |
- int nonPlatformSize = 0; |
- for (LibraryElement lib in userLibraries) { |
- for (CompilationUnitElement compilationUnit in lib.compilationUnits) { |
- nonPlatformSize += compilationUnit.script.file.length; |
- } |
- } |
- int percentage = totalOutputSize * 100 ~/ nonPlatformSize; |
- log('Total used non-platform files size: ${nonPlatformSize} bytes, ' |
- 'Output total size: $totalOutputSize bytes (${percentage}%)'); |
- } |
- |
- log(String message) => reporter.log('[DartBackend] $message'); |
- |
- @override |
- Future onLibrariesLoaded(LoadedLibraries loadedLibraries) { |
- // All platform classes must be resolved to ensure that their member names |
- // are preserved. |
- loadedLibraries.forEachLibrary((LibraryElement library) { |
- if (library.isPlatformLibrary) { |
- library.forEachLocalMember((Element element) { |
- if (element.isClass) { |
- ClassElement classElement = element; |
- classElement.ensureResolved(resolution); |
- } |
- }); |
- } |
- }); |
- if (useMirrorHelperLibrary && |
- loadedLibraries.containsLibrary(Uris.dart_mirrors)) { |
- return compiler.libraryLoader |
- .loadLibrary(compiler.resolvedUriTranslator.translate( |
- loadedLibraries.getLibrary(Uris.dart_mirrors), |
- MirrorRenamerImpl.DART_MIRROR_HELPER, |
- null)) |
- .then((LibraryElement library) { |
- mirrorRenamer = new MirrorRenamerImpl(compiler, this, library); |
- }); |
- } |
- return new Future.value(); |
- } |
- |
- @override |
- void registerStaticUse(Element element, Enqueuer enqueuer) { |
- if (element == compiler.mirrorSystemGetNameFunction) { |
- FunctionElement getNameFunction = mirrorRenamer.getNameFunction; |
- if (getNameFunction != null) { |
- enqueuer.addToWorkList(getNameFunction); |
- } |
- } |
- } |
- |
- @override |
- void registerInstantiatedType( |
- InterfaceType type, Enqueuer enqueuer, Registry registry, |
- {bool mirrorUsage: false}) { |
- registerPlatformMembers(type, registerUse: registry.registerDynamicUse); |
- super.registerInstantiatedType(type, enqueuer, registry, |
- mirrorUsage: mirrorUsage); |
- } |
- |
- /// Register dynamic access of members of [type] that implement members |
- /// of types defined in the platform libraries. |
- void registerPlatformMembers(InterfaceType type, |
- {void registerUse(DynamicUse dynamicUse)}) { |
- // Without patching, dart2dart has no way of performing sound tree-shaking |
- // in face external functions. Therefore we employ another scheme: |
- // |
- // Based on the assumption that the platform code only relies on the |
- // interfaces of it's own classes, we can approximate the semantics of |
- // external functions by eagerly registering dynamic invocation of instance |
- // members defined the platform interfaces. |
- // |
- // Since we only need to generate code for non-platform classes we can |
- // restrict this registration to platform interfaces implemented by |
- // instantiated non-platform classes. |
- // |
- // Consider for instance this program: |
- // |
- // import 'dart:math' show Random; |
- // |
- // class MyRandom implements Random { |
- // int nextInt() => 0; |
- // } |
- // |
- // main() { |
- // print([0, 1, 2].shuffle(new MyRandom())); |
- // } |
- // |
- // Here `MyRandom` is a subtype if `Random` defined in 'dart:math'. By the |
- // assumption, all methods defined `Random` are potentially called, and |
- // therefore, though there are no visible call sites from the user node, |
- // dynamic invocation of for instance `nextInt` should be registered. In |
- // this case, `nextInt` is actually called by the standard implementation of |
- // `shuffle`. |
- |
- ClassElement cls = type.element; |
- if (!cls.library.isPlatformLibrary) { |
- for (Link<DartType> link = cls.allSupertypes; |
- !link.isEmpty; |
- link = link.tail) { |
- InterfaceType supertype = link.head; |
- ClassElement superclass = supertype.element; |
- LibraryElement library = superclass.library; |
- if (library.isPlatformLibrary) { |
- if (_userImplementedPlatformClasses.add(superclass)) { |
- // Register selectors for all instance methods since these might |
- // be called on user classes from within the platform |
- // implementation. |
- superclass.forEachLocalMember((MemberElement element) { |
- if (element.isConstructor || element.isStatic) return; |
- |
- element.computeType(resolution); |
- Selector selector = new Selector.fromElement(element); |
- registerUse(new DynamicUse(selector, null)); |
- }); |
- } |
- } |
- } |
- } |
- } |
- |
- @override |
- bool enableDeferredLoadingIfSupported(Spannable node, Registry registry) { |
- // TODO(sigurdm): Implement deferred loading for dart2dart. |
- reporter.reportWarningMessage( |
- node, MessageKind.DEFERRED_LIBRARY_DART_2_DART); |
- return false; |
- } |
- |
- @override |
- Uri resolvePatchUri(String libraryName, Uri) { |
- // Dart2dart does not use patches. |
- return null; |
- } |
-} |
- |
-class DartImpactTransformer extends ImpactTransformer { |
- final DartBackend backend; |
- |
- DartImpactTransformer(this.backend); |
- |
- @override |
- WorldImpact transformResolutionImpact(ResolutionImpact worldImpact) { |
- TransformedWorldImpact transformed = |
- new TransformedWorldImpact(worldImpact); |
- for (TypeUse typeUse in worldImpact.typeUses) { |
- if (typeUse.kind == TypeUseKind.TYPE_LITERAL && |
- typeUse.type.isInterfaceType) { |
- backend.usedTypeLiterals.add(typeUse.type.element); |
- } |
- if (typeUse.kind == TypeUseKind.INSTANTIATION) { |
- backend.registerPlatformMembers(typeUse.type, |
- registerUse: transformed.registerDynamicUse); |
- } |
- } |
- return transformed; |
- } |
-} |
- |
-class EmitterUnparser extends Unparser { |
- final Map<Node, String> renames; |
- |
- EmitterUnparser(this.renames, {bool minify, bool stripTypes}) |
- : super(minify: minify, stripTypes: stripTypes); |
- |
- visit(Node node) { |
- if (node != null && renames.containsKey(node)) { |
- write(renames[node]); |
- } else { |
- super.visit(node); |
- } |
- } |
- |
- unparseSendReceiver(Send node, {bool spacesNeeded: false}) { |
- // TODO(smok): Remove ugly hack for library prefices. |
- if (node.receiver != null && renames[node.receiver] == '') return; |
- super.unparseSendReceiver(node, spacesNeeded: spacesNeeded); |
- } |
- |
- unparseFunctionName(Node name) { |
- if (name != null && renames.containsKey(name)) { |
- write(renames[name]); |
- } else { |
- super.unparseFunctionName(name); |
- } |
- } |
-} |
- |
-/** |
- * Some elements are not recorded by resolver now, |
- * for example, typedefs or classes which are only |
- * used in signatures, as/is operators or in super clauses |
- * (just to name a few). Retraverse AST to pick those up. |
- */ |
-class ReferencedElementCollector extends Visitor { |
- final DiagnosticReporter reporter; |
- final Element element; |
- final ElementAst elementAst; |
- final newTypedefElementCallback; |
- final newClassElementCallback; |
- |
- ReferencedElementCollector(this.reporter, this.element, this.elementAst, |
- this.newTypedefElementCallback, this.newClassElementCallback); |
- |
- visitNode(Node node) { |
- node.visitChildren(this); |
- } |
- |
- visitTypeAnnotation(TypeAnnotation typeAnnotation) { |
- TreeElements treeElements = elementAst.treeElements; |
- final DartType type = treeElements.getType(typeAnnotation); |
- assert(invariant(typeAnnotation, type != null, |
- message: "Missing type for type annotation: $treeElements.")); |
- if (type.isTypedef) newTypedefElementCallback(type.element); |
- if (type.isInterfaceType) newClassElementCallback(type.element); |
- typeAnnotation.visitChildren(this); |
- } |
- |
- void collect() { |
- reporter.withCurrentElement(element, () { |
- elementAst.ast.accept(this); |
- }); |
- } |
-} |
- |
-Comparator compareBy(f) => (x, y) => f(x).compareTo(f(y)); |
- |
-List sorted(Iterable l, comparison) { |
- final result = new List.from(l); |
- result.sort(comparison); |
- return result; |
-} |
- |
-compareElements(e0, e1) { |
- int result = compareBy((e) => e.library.canonicalUri.toString())(e0, e1); |
- if (result != 0) return result; |
- return compareBy((e) => e.position.charOffset)(e0, e1); |
-} |
- |
-/// [ConstantCompilerTask] for compilation of constants for the Dart backend. |
-/// |
-/// Since this task needs no distinction between frontend and backend constants |
-/// it also serves as the [BackendConstantEnvironment]. |
-class DartConstantTask extends ConstantCompilerTask |
- implements BackendConstantEnvironment { |
- final DartConstantCompiler constantCompiler; |
- |
- DartConstantTask(Compiler compiler) |
- : this.constantCompiler = new DartConstantCompiler(compiler), |
- super(compiler.measurer); |
- |
- String get name => 'ConstantHandler'; |
- |
- @override |
- ConstantSystem get constantSystem => constantCompiler.constantSystem; |
- |
- @override |
- bool hasConstantValue(ConstantExpression expression) { |
- return constantCompiler.hasConstantValue(expression); |
- } |
- |
- @override |
- ConstantValue getConstantValue(ConstantExpression expression) { |
- return constantCompiler.getConstantValue(expression); |
- } |
- |
- @override |
- ConstantValue getConstantValueForVariable(VariableElement element) { |
- return constantCompiler.getConstantValueForVariable(element); |
- } |
- |
- @override |
- ConstantExpression getConstantForNode(Node node, TreeElements elements) { |
- return constantCompiler.getConstantForNode(node, elements); |
- } |
- |
- @override |
- ConstantValue getConstantValueForNode(Node node, TreeElements elements) { |
- return getConstantValue( |
- constantCompiler.getConstantForNode(node, elements)); |
- } |
- |
- @override |
- ConstantValue getConstantValueForMetadata(MetadataAnnotation metadata) { |
- return getConstantValue(metadata.constant); |
- } |
- |
- @override |
- ConstantExpression compileConstant(VariableElement element) { |
- return measure(() { |
- return constantCompiler.compileConstant(element); |
- }); |
- } |
- |
- @override |
- void evaluate(ConstantExpression constant) { |
- return measure(() { |
- return constantCompiler.evaluate(constant); |
- }); |
- } |
- |
- @override |
- ConstantExpression compileVariable(VariableElement element) { |
- return measure(() { |
- return constantCompiler.compileVariable(element); |
- }); |
- } |
- |
- @override |
- ConstantExpression compileNode(Node node, TreeElements elements, |
- {bool enforceConst: true}) { |
- return measure(() { |
- return constantCompiler.compileNodeWithDefinitions(node, elements, |
- isConst: enforceConst); |
- }); |
- } |
- |
- @override |
- ConstantExpression compileMetadata( |
- MetadataAnnotation metadata, Node node, TreeElements elements) { |
- return measure(() { |
- return constantCompiler.compileMetadata(metadata, node, elements); |
- }); |
- } |
- |
- // TODO(johnniwinther): Remove this when values are computed from the |
- // expressions. |
- @override |
- void copyConstantValues(DartConstantTask task) { |
- constantCompiler.constantValueMap |
- .addAll(task.constantCompiler.constantValueMap); |
- } |
- |
- @override |
- void registerLazyStatic(FieldElement element) { |
- // Do nothing. |
- } |
-} |