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

Unified Diff: test/codegen/lib/mirrors/mirrors_reader.dart

Issue 2265533002: Add mirrors tests (Closed) Base URL: https://github.com/dart-lang/dev_compiler.git@master
Patch Set: Created 4 years, 4 months 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
« no previous file with comments | « test/codegen/lib/mirrors/mirrors_nsm_test.dart ('k') | test/codegen/lib/mirrors/mirrors_reader_test.dart » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: test/codegen/lib/mirrors/mirrors_reader.dart
diff --git a/test/codegen/lib/mirrors/mirrors_reader.dart b/test/codegen/lib/mirrors/mirrors_reader.dart
new file mode 100644
index 0000000000000000000000000000000000000000..7b7bbc28d54237020f6c0a2a6554252d8e530c78
--- /dev/null
+++ b/test/codegen/lib/mirrors/mirrors_reader.dart
@@ -0,0 +1,263 @@
+// Copyright (c) 2014, 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 LICESNE file.
+
+library mirrors.reader;
+
+import 'dart:mirrors';
+import 'mirrors_visitor.dart';
+
+class ReadError {
+ final String tag;
+ final exception;
+ final StackTrace stackTrace;
+
+ ReadError(this.tag, this.exception, this.stackTrace);
+}
+
+class MirrorsReader extends MirrorsVisitor {
+ /// Produce verbose output.
+ final bool verbose;
+ /// Include stack trace in the error report.
+ final bool includeStackTrace;
+
+ bool fatalError = false;
+ Set<Mirror> visited = new Set<Mirror>();
+ Set<TypeMirror> declarations = new Set<TypeMirror>();
+ Set<TypeMirror> instantiations = new Set<TypeMirror>();
+ List<ReadError> errors = <ReadError>[];
+ List<Mirror> queue = <Mirror>[];
+
+ MirrorsReader({this.verbose: false, this.includeStackTrace: false});
+
+ void checkMirrorSystem(MirrorSystem mirrorSystem) {
+ visitMirrorSystem(mirrorSystem);
+ if (!errors.isEmpty) {
+ Set<String> errorMessages = new Set<String>();
+ for (ReadError error in errors) {
+ String text = 'Mirrors read error: ${error.tag}=${error.exception}';
+ if (includeStackTrace) {
+ text = '$text\n${error.stackTrace}';
+ }
+ if (errorMessages.add(text)) {
+ print(text);
+ }
+ }
+ throw 'Unexpected errors occurred reading mirrors.';
+ }
+ }
+
+ // Skip mirrors so that each mirror is only visited once.
+ bool skipMirror(Mirror mirror) {
+ if (fatalError) return true;
+ if (mirror is TypeMirror) {
+ if (mirror.isOriginalDeclaration) {
+ // Visit the declation once.
+ return !declarations.add(mirror);
+ } else {
+ // Visit only one instantiation.
+ return !instantiations.add(mirror.originalDeclaration);
+ }
+ }
+ return !visited.add(mirror);
+ }
+
+ reportError(var receiver, String tag, var exception, StackTrace stackTrace) {
+ String errorTag = '${receiver.runtimeType}.$tag';
+ errors.add(new ReadError(errorTag, exception, stackTrace));
+ }
+
+ visitUnsupported(var receiver, String tag,
+ UnsupportedError exception,
+ StackTrace stackTrace) {
+ if (verbose) print('visitUnsupported:$receiver.$tag:$exception');
+ if (!expectUnsupported(receiver, tag, exception) &&
+ !allowUnsupported(receiver, tag, exception)) {
+ reportError(receiver, tag, exception, stackTrace);
+ }
+ }
+
+ /// Override to specify that access is expected to be unsupported.
+ bool expectUnsupported(var receiver, String tag,
+ UnsupportedError exception) => false;
+
+ /// Override to allow unsupported access.
+ bool allowUnsupported(var receiver, String tag,
+ UnsupportedError exception) => false;
+
+ /// Evaluates the function [f]. Subclasses can override this to handle
+ /// specific exceptions.
+ evaluate(f()) => f();
+
+ visit(var receiver, String tag, var value) {
+ if (value is Function) {
+ try {
+ var result = evaluate(value);
+ if (expectUnsupported(receiver, tag, null)) {
+ reportError(receiver, tag, 'Expected UnsupportedError.', null);
+ }
+ return visit(receiver, tag, result);
+ } on UnsupportedError catch (e, s) {
+ visitUnsupported(receiver, tag, e, s);
+ } on OutOfMemoryError catch (e, s) {
+ reportError(receiver, tag, e, s);
+ fatalError = true;
+ } on StackOverflowError catch (e, s) {
+ reportError(receiver, tag, e, s);
+ fatalError = true;
+ } catch (e, s) {
+ reportError(receiver, tag, e, s);
+ }
+ } else {
+ if (value is Mirror) {
+ if (!skipMirror(value)) {
+ if (verbose) print('visit:$receiver.$tag=$value');
+ bool drain = queue.isEmpty;
+ queue.add(value);
+ if (drain) {
+ while (!queue.isEmpty) {
+ visitMirror(queue.removeLast());
+ }
+ }
+ }
+ } else if (value is MirrorSystem) {
+ visitMirrorSystem(value);
+ } else if (value is SourceLocation) {
+ visitSourceLocation(value);
+ } else if (value is Iterable) {
+ // TODO(johnniwinther): Merge with `immutable_collections_test.dart`.
+ value.forEach((e) {
+ visit(receiver, tag, e);
+ });
+ } else if (value is Map) {
+ value.forEach((k, v) {
+ visit(receiver, tag, k);
+ visit(receiver, tag, v);
+ });
+ }
+ }
+ return value;
+ }
+
+ visitMirrorSystem(MirrorSystem mirrorSystem) {
+ visit(mirrorSystem, 'dynamicType', () => mirrorSystem.dynamicType);
+ visit(mirrorSystem, 'voidType', () => mirrorSystem.voidType);
+ visit(mirrorSystem, 'libraries', () => mirrorSystem.libraries);
+ }
+
+ visitClassMirror(ClassMirror mirror) {
+ super.visitClassMirror(mirror);
+ visit(mirror, 'declarations', () => mirror.declarations);
+ bool hasReflectedType =
+ visit(mirror, 'hasReflectedType', () => mirror.hasReflectedType);
+ visit(mirror, 'instanceMembers', () => mirror.instanceMembers);
+ visit(mirror, 'mixin', () => mirror.mixin);
+ if (hasReflectedType) {
+ visit(mirror, 'reflectedType', () => mirror.reflectedType);
+ }
+ visit(mirror, 'staticMembers', () => mirror.staticMembers);
+ visit(mirror, 'superclass', () => mirror.superclass);
+ visit(mirror, 'superinterfaces', () => mirror.superinterfaces);
+ }
+
+ visitDeclarationMirror(DeclarationMirror mirror) {
+ super.visitDeclarationMirror(mirror);
+ visit(mirror, 'isPrivate', () => mirror.isPrivate);
+ visit(mirror, 'isTopLevel', () => mirror.isTopLevel);
+ visit(mirror, 'location', () => mirror.location);
+ visit(mirror, 'metadata', () => mirror.metadata);
+ visit(mirror, 'owner', () => mirror.owner);
+ visit(mirror, 'qualifiedName', () => mirror.qualifiedName);
+ visit(mirror, 'simpleName', () => mirror.simpleName);
+ }
+
+ visitFunctionTypeMirror(FunctionTypeMirror mirror) {
+ super.visitFunctionTypeMirror(mirror);
+ visit(mirror, 'callMethod', () => mirror.callMethod);
+ visit(mirror, 'parameters', () => mirror.parameters);
+ visit(mirror, 'returnType', () => mirror.returnType);
+ }
+
+ visitInstanceMirror(InstanceMirror mirror) {
+ super.visitInstanceMirror(mirror);
+ bool hasReflectee =
+ visit(mirror, 'hasReflectee', () => mirror.hasReflectee);
+ if (hasReflectee) {
+ visit(mirror, 'reflectee', () => mirror.reflectee);
+ }
+ visit(mirror, 'type', () => mirror.type);
+ }
+
+ visitLibraryMirror(LibraryMirror mirror) {
+ super.visitLibraryMirror(mirror);
+ visit(mirror, 'declarations', () => mirror.declarations);
+ visit(mirror, 'uri', () => mirror.uri);
+ }
+
+ visitMethodMirror(MethodMirror mirror) {
+ super.visitMethodMirror(mirror);
+ visit(mirror, 'constructorName', () => mirror.constructorName);
+ visit(mirror, 'isAbstract', () => mirror.isAbstract);
+ visit(mirror, 'isConstConstructor', () => mirror.isConstConstructor);
+ visit(mirror, 'isConstructor', () => mirror.isConstructor);
+ visit(mirror, 'isFactoryConstructor',
+ () => mirror.isFactoryConstructor);
+ visit(mirror, 'isGenerativeConstructor',
+ () => mirror.isGenerativeConstructor);
+ visit(mirror, 'isGetter', () => mirror.isGetter);
+ visit(mirror, 'isOperator', () => mirror.isOperator);
+ visit(mirror, 'isRedirectingConstructor',
+ () => mirror.isRedirectingConstructor);
+ visit(mirror, 'isRegularMethod', () => mirror.isRegularMethod);
+ visit(mirror, 'isSetter', () => mirror.isSetter);
+ visit(mirror, 'isStatic', () => mirror.isStatic);
+ visit(mirror, 'isSynthetic', () => mirror.isSynthetic);
+ visit(mirror, 'parameters', () => mirror.parameters);
+ visit(mirror, 'returnType', () => mirror.returnType);
+ visit(mirror, 'source', () => mirror.source);
+ }
+
+ visitParameterMirror(ParameterMirror mirror) {
+ super.visitParameterMirror(mirror);
+ bool hasDefaultValue =
+ visit(mirror, 'hasDefaultValue', () => mirror.hasDefaultValue);
+ if (hasDefaultValue) {
+ visit(mirror, 'defaultValue', () => mirror.defaultValue);
+ }
+ visit(mirror, 'isNamed', () => mirror.isNamed);
+ visit(mirror, 'isOptional', () => mirror.isOptional);
+ visit(mirror, 'type', () => mirror.type);
+ }
+
+ visitSourceLocation(SourceLocation location) {
+
+ }
+
+ visitTypedefMirror(TypedefMirror mirror) {
+ super.visitTypedefMirror(mirror);
+ visit(mirror, 'referent', () => mirror.referent);
+ }
+
+ visitTypeMirror(TypeMirror mirror) {
+ super.visitTypeMirror(mirror);
+ visit(mirror, 'isOriginalDeclaration',
+ () => mirror.isOriginalDeclaration);
+ visit(mirror, 'originalDeclaration', () => mirror.originalDeclaration);
+ visit(mirror, 'typeArguments', () => mirror.typeArguments);
+ visit(mirror, 'typeVariables', () => mirror.typeVariables);
+ }
+
+ visitTypeVariableMirror(TypeVariableMirror mirror) {
+ super.visitTypeVariableMirror(mirror);
+ visit(mirror, 'upperBound', () => mirror.upperBound);
+ visit(mirror, 'isStatic', () => mirror.isStatic);
+ }
+
+ visitVariableMirror(VariableMirror mirror) {
+ super.visitVariableMirror(mirror);
+ visit(mirror, 'isConst', () => mirror.isConst);
+ visit(mirror, 'isFinal', () => mirror.isFinal);
+ visit(mirror, 'isStatic', () => mirror.isStatic);
+ visit(mirror, 'type', () => mirror.type);
+ }
+}
« no previous file with comments | « test/codegen/lib/mirrors/mirrors_nsm_test.dart ('k') | test/codegen/lib/mirrors/mirrors_reader_test.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698