| // 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. |
| |
| import "package:expect/expect.dart"; |
| import "../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart"; |
| import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart"; |
| import "../../../sdk/lib/_internal/compiler/implementation/tree/tree.dart"; |
| import "../../../sdk/lib/_internal/compiler/implementation/util/util.dart"; |
| import "mock_compiler.dart"; |
| import "parser_helper.dart"; |
| import "dart:uri"; |
| |
| Compiler applyPatch(String script, String patch) { |
| String core = "$DEFAULT_CORELIB\n$script"; |
| MockCompiler compiler = new MockCompiler(coreSource: core); |
| var uri = new Uri("core.dartp"); |
| compiler.sourceFiles[uri.toString()] = new MockFile(patch); |
| var handler = new LibraryDependencyHandler(compiler); |
| compiler.patchParser.patchLibrary(handler, uri, compiler.coreLibrary); |
| handler.computeExports(); |
| return compiler; |
| } |
| |
| void expectHasBody(compiler, Element element) { |
| var node = element.parseNode(compiler); |
| Expect.isNotNull(node, "Element isn't parseable, when a body was expected"); |
| Expect.isNotNull(node.body); |
| // If the element has a body it is either a Block or a Return statement, |
| // both with different begin and end tokens. |
| Expect.isTrue(node.body is Block || node.body is Return); |
| Expect.notEquals(node.body.getBeginToken(), node.body.getEndToken()); |
| } |
| |
| void expectHasNoBody(compiler, Element element) { |
| var node = element.parseNode(compiler); |
| Expect.isNotNull(node, "Element isn't parseable, when a body was expected"); |
| Expect.isFalse(node.hasBody()); |
| } |
| |
| Element ensure(compiler, |
| String name, |
| Element lookup(name), |
| {bool expectIsPatched: false, |
| bool expectIsPatch: false, |
| bool checkHasBody: false, |
| bool expectIsGetter: false, |
| bool expectIsFound: true, |
| bool expectIsRegular: false}) { |
| var element = lookup(buildSourceString(name)); |
| if (!expectIsFound) { |
| Expect.isNull(element); |
| return element; |
| } |
| Expect.isNotNull(element); |
| if (expectIsGetter) { |
| Expect.isTrue(element is AbstractFieldElement); |
| Expect.isNotNull(element.getter); |
| element = element.getter; |
| } |
| Expect.equals(expectIsPatched, element.isPatched); |
| if (expectIsPatched) { |
| Expect.isNull(element.origin); |
| Expect.isNotNull(element.patch); |
| |
| Expect.equals(element, element.declaration); |
| Expect.equals(element.patch, element.implementation); |
| |
| if (checkHasBody) { |
| expectHasNoBody(compiler, element); |
| expectHasBody(compiler, element.patch); |
| } |
| } else { |
| Expect.isTrue(element.isImplementation); |
| } |
| Expect.equals(expectIsPatch, element.isPatch); |
| if (expectIsPatch) { |
| Expect.isNotNull(element.origin); |
| Expect.isNull(element.patch); |
| |
| Expect.equals(element.origin, element.declaration); |
| Expect.equals(element, element.implementation); |
| |
| if (checkHasBody) { |
| expectHasBody(compiler, element); |
| expectHasNoBody(compiler, element.origin); |
| } |
| } else { |
| Expect.isTrue(element.isDeclaration); |
| } |
| if (expectIsRegular) { |
| Expect.isNull(element.origin); |
| Expect.isNull(element.patch); |
| |
| Expect.equals(element, element.declaration); |
| Expect.equals(element, element.implementation); |
| |
| if (checkHasBody) { |
| expectHasBody(compiler, element); |
| } |
| } |
| Expect.isFalse(element.isPatched && element.isPatch); |
| return element; |
| } |
| |
| testPatchFunction() { |
| var compiler = applyPatch( |
| "external test();", |
| "patch test() { return 'string'; } "); |
| ensure(compiler, "test", compiler.coreLibrary.find, |
| expectIsPatched: true, checkHasBody: true); |
| ensure(compiler, "test", compiler.coreLibrary.patch.find, |
| expectIsPatch: true, checkHasBody: true); |
| |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isTrue(compiler.errors.isEmpty, |
| "Unexpected errors: ${compiler.errors}"); |
| } |
| |
| testPatchConstructor() { |
| var compiler = applyPatch( |
| """ |
| class Class { |
| external Class(); |
| } |
| """, |
| """ |
| patch class Class { |
| patch Class(); |
| } |
| """); |
| var classOrigin = ensure(compiler, "Class", compiler.coreLibrary.find, |
| expectIsPatched: true); |
| classOrigin.ensureResolved(compiler); |
| var classPatch = ensure(compiler, "Class", compiler.coreLibrary.patch.find, |
| expectIsPatch: true); |
| |
| Expect.equals(classPatch, classOrigin.patch); |
| Expect.equals(classOrigin, classPatch.origin); |
| |
| var constructorOrigin = ensure(compiler, "Class", |
| (name) => classOrigin.localLookup(name), |
| expectIsPatched: true); |
| var constructorPatch = ensure(compiler, "Class", |
| (name) => classPatch.localLookup(name), |
| expectIsPatch: true); |
| |
| Expect.equals(constructorPatch, constructorOrigin.patch); |
| Expect.equals(constructorOrigin, constructorPatch.origin); |
| |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isTrue(compiler.errors.isEmpty, |
| "Unexpected errors: ${compiler.errors}"); |
| } |
| |
| testPatchMember() { |
| var compiler = applyPatch( |
| """ |
| class Class { |
| external String toString(); |
| } |
| """, |
| """ |
| patch class Class { |
| patch String toString() => 'string'; |
| } |
| """); |
| var container = ensure(compiler, "Class", compiler.coreLibrary.find, |
| expectIsPatched: true); |
| container.parseNode(compiler); |
| ensure(compiler, "Class", compiler.coreLibrary.patch.find, |
| expectIsPatch: true); |
| |
| ensure(compiler, "toString", container.lookupLocalMember, |
| expectIsPatched: true, checkHasBody: true); |
| ensure(compiler, "toString", container.patch.lookupLocalMember, |
| expectIsPatch: true, checkHasBody: true); |
| |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isTrue(compiler.errors.isEmpty, |
| "Unexpected errors: ${compiler.errors}"); |
| } |
| |
| testPatchGetter() { |
| var compiler = applyPatch( |
| """ |
| class Class { |
| external int get field; |
| } |
| """, |
| """ |
| patch class Class { |
| patch int get field => 5; |
| } |
| """); |
| var container = ensure(compiler, "Class", compiler.coreLibrary.find, |
| expectIsPatched: true); |
| container.parseNode(compiler); |
| ensure(compiler, |
| "field", |
| container.lookupLocalMember, |
| expectIsGetter: true, |
| expectIsPatched: true, |
| checkHasBody: true); |
| ensure(compiler, |
| "field", |
| container.patch.lookupLocalMember, |
| expectIsGetter: true, |
| expectIsPatch: true, |
| checkHasBody: true); |
| |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isTrue(compiler.errors.isEmpty, |
| "Unexpected errors: ${compiler.errors}"); |
| } |
| |
| testRegularMember() { |
| var compiler = applyPatch( |
| """ |
| class Class { |
| void regular() {} |
| } |
| """, |
| """ |
| patch class Class { |
| } |
| """); |
| var container = ensure(compiler, "Class", compiler.coreLibrary.find, |
| expectIsPatched: true); |
| container.parseNode(compiler); |
| ensure(compiler, "Class", compiler.coreLibrary.patch.find, |
| expectIsPatch: true); |
| |
| ensure(compiler, "regular", container.lookupLocalMember, |
| checkHasBody: true, expectIsRegular: true); |
| ensure(compiler, "regular", container.patch.lookupLocalMember, |
| checkHasBody: true, expectIsRegular: true); |
| |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isTrue(compiler.errors.isEmpty, |
| "Unexpected errors: ${compiler.errors}"); |
| } |
| |
| testGhostMember() { |
| var compiler = applyPatch( |
| """ |
| class Class { |
| } |
| """, |
| """ |
| patch class Class { |
| void ghost() {} |
| } |
| """); |
| var container = ensure(compiler, "Class", compiler.coreLibrary.find, |
| expectIsPatched: true); |
| container.parseNode(compiler); |
| ensure(compiler, "Class", compiler.coreLibrary.patch.find, |
| expectIsPatch: true); |
| |
| ensure(compiler, "ghost", container.lookupLocalMember, |
| expectIsFound: false); |
| ensure(compiler, "ghost", container.patch.lookupLocalMember, |
| checkHasBody: true, expectIsRegular: true); |
| |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isTrue(compiler.errors.isEmpty, |
| "Unexpected errors: ${compiler.errors}"); |
| } |
| |
| testInjectFunction() { |
| var compiler = applyPatch( |
| "", |
| "int _function() => 5;"); |
| ensure(compiler, |
| "_function", |
| compiler.coreLibrary.find, |
| expectIsFound: false); |
| ensure(compiler, |
| "_function", |
| compiler.coreLibrary.patch.find, |
| checkHasBody: true, expectIsRegular: true); |
| |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isTrue(compiler.errors.isEmpty, |
| "Unexpected errors: ${compiler.errors}"); |
| } |
| |
| testPatchSignatureCheck() { |
| var compiler = applyPatch( |
| """ |
| class Class { |
| external String method1(); |
| external void method2(String str); |
| external void method3(String s1); |
| external void method4([String str]); |
| external void method5({String str}); |
| external void method6({String str}); |
| external void method7([String s1]); |
| external void method8({String s1}); |
| } |
| """, |
| """ |
| patch class Class { |
| patch int method1() => 0; |
| patch void method2() {} |
| patch void method3(String s2) {} |
| patch void method4([String str, int i]) {} |
| patch void method5() {} |
| patch void method6([String str]) {} |
| patch void method7([String s2]) {} |
| patch void method8({String s2}) {} |
| } |
| """); |
| var container = ensure(compiler, "Class", compiler.coreLibrary.find, |
| expectIsPatched: true); |
| container.ensureResolved(compiler); |
| container.parseNode(compiler); |
| |
| compiler.resolver.resolveMethodElement( |
| ensure(compiler, "method1", container.lookupLocalMember, |
| expectIsPatched: true, checkHasBody: true)); |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isFalse(compiler.errors.isEmpty); |
| print('method1:${compiler.errors}'); |
| |
| compiler.warnings.clear(); |
| compiler.errors.clear(); |
| compiler.resolver.resolveMethodElement( |
| ensure(compiler, "method2", container.lookupLocalMember, |
| expectIsPatched: true, checkHasBody: true)); |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isFalse(compiler.errors.isEmpty); |
| print('method2:${compiler.errors}'); |
| |
| compiler.warnings.clear(); |
| compiler.errors.clear(); |
| compiler.resolver.resolveMethodElement( |
| ensure(compiler, "method3", container.lookupLocalMember, |
| expectIsPatched: true, checkHasBody: true)); |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isFalse(compiler.errors.isEmpty); |
| print('method3:${compiler.errors}'); |
| |
| compiler.warnings.clear(); |
| compiler.errors.clear(); |
| compiler.resolver.resolveMethodElement( |
| ensure(compiler, "method4", container.lookupLocalMember, |
| expectIsPatched: true, checkHasBody: true)); |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isFalse(compiler.errors.isEmpty); |
| print('method4:${compiler.errors}'); |
| |
| compiler.warnings.clear(); |
| compiler.errors.clear(); |
| compiler.resolver.resolveMethodElement( |
| ensure(compiler, "method5", container.lookupLocalMember, |
| expectIsPatched: true, checkHasBody: true)); |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isFalse(compiler.errors.isEmpty); |
| print('method5:${compiler.errors}'); |
| |
| compiler.warnings.clear(); |
| compiler.errors.clear(); |
| compiler.resolver.resolveMethodElement( |
| ensure(compiler, "method6", container.lookupLocalMember, |
| expectIsPatched: true, checkHasBody: true)); |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isFalse(compiler.errors.isEmpty); |
| print('method6:${compiler.errors}'); |
| |
| compiler.warnings.clear(); |
| compiler.errors.clear(); |
| compiler.resolver.resolveMethodElement( |
| ensure(compiler, "method7", container.lookupLocalMember, |
| expectIsPatched: true, checkHasBody: true)); |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isFalse(compiler.errors.isEmpty); |
| print('method7:${compiler.errors}'); |
| |
| compiler.warnings.clear(); |
| compiler.errors.clear(); |
| compiler.resolver.resolveMethodElement( |
| ensure(compiler, "method8", container.lookupLocalMember, |
| expectIsPatched: true, checkHasBody: true)); |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| Expect.isFalse(compiler.errors.isEmpty); |
| print('method8:${compiler.errors}'); |
| } |
| |
| testExternalWithoutImplementationTopLevel() { |
| var compiler = applyPatch( |
| """ |
| external void foo(); |
| """, |
| """ |
| // patch void foo() {} |
| """); |
| var function = ensure(compiler, "foo", compiler.coreLibrary.find); |
| compiler.resolver.resolve(function); |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| print('testExternalWithoutImplementationTopLevel:${compiler.errors}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == |
| MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION); |
| Expect.equals('External method without an implementation.', |
| compiler.errors[0].message.toString()); |
| } |
| |
| testExternalWithoutImplementationMember() { |
| var compiler = applyPatch( |
| """ |
| class Class { |
| external void foo(); |
| } |
| """, |
| """ |
| patch class Class { |
| // patch void foo() {} |
| } |
| """); |
| var container = ensure(compiler, "Class", compiler.coreLibrary.find, |
| expectIsPatched: true); |
| container.parseNode(compiler); |
| |
| compiler.warnings.clear(); |
| compiler.errors.clear(); |
| compiler.resolver.resolveMethodElement( |
| ensure(compiler, "foo", container.lookupLocalMember)); |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| print('testExternalWithoutImplementationMember:${compiler.errors}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == |
| MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION); |
| Expect.equals('External method without an implementation.', |
| compiler.errors[0].message.toString()); |
| } |
| |
| testIsSubclass() { |
| var compiler = applyPatch( |
| """ |
| class A {} |
| """, |
| """ |
| patch class A {} |
| """); |
| ClassElement cls = ensure(compiler, "A", compiler.coreLibrary.find, |
| expectIsPatched: true); |
| ClassElement patch = cls.patch; |
| Expect.isTrue(cls != patch); |
| Expect.isTrue(cls.isSubclassOf(patch)); |
| Expect.isTrue(patch.isSubclassOf(cls)); |
| } |
| |
| testPatchNonExistingTopLevel() { |
| var compiler = applyPatch( |
| """ |
| // class Class {} |
| """, |
| """ |
| patch class Class {} |
| """); |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| print('testPatchNonExistingTopLevel:${compiler.errors}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXISTING); |
| } |
| |
| testPatchNonExistingMember() { |
| var compiler = applyPatch( |
| """ |
| class Class {} |
| """, |
| """ |
| patch class Class { |
| patch void foo() {} |
| } |
| """); |
| var container = ensure(compiler, "Class", compiler.coreLibrary.find, |
| expectIsPatched: true); |
| container.parseNode(compiler); |
| |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| print('testPatchNonExistingMember:${compiler.errors}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXISTING); |
| } |
| |
| testPatchNonPatchablePatch() { |
| var compiler = applyPatch( |
| """ |
| external get foo; |
| """, |
| """ |
| patch var foo; |
| """); |
| ensure(compiler, "foo", compiler.coreLibrary.find); |
| |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| print('testPatchNonPatchablePatch:${compiler.errors}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == MessageKind.PATCH_NONPATCHABLE); |
| } |
| |
| testPatchNonPatchableOrigin() { |
| var compiler = applyPatch( |
| """ |
| external var foo; |
| """, |
| """ |
| patch get foo => 0; |
| """); |
| ensure(compiler, "foo", compiler.coreLibrary.find); |
| |
| Expect.isTrue(compiler.warnings.isEmpty, |
| "Unexpected warnings: ${compiler.warnings}"); |
| print('testPatchNonPatchableOrigin:${compiler.errors}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == MessageKind.PATCH_NONPATCHABLE); |
| } |
| |
| testPatchNonExternalTopLevel() { |
| var compiler = applyPatch( |
| """ |
| void foo() {} |
| """, |
| """ |
| patch void foo() {} |
| """); |
| print('testPatchNonExternalTopLevel.errors:${compiler.errors}'); |
| print('testPatchNonExternalTopLevel.warnings:${compiler.warnings}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXTERNAL); |
| Expect.equals(1, compiler.warnings.length); |
| Expect.isTrue( |
| compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_FUNCTION); |
| } |
| |
| testPatchNonExternalMember() { |
| var compiler = applyPatch( |
| """ |
| class Class { |
| void foo() {} |
| } |
| """, |
| """ |
| patch class Class { |
| patch void foo() {} |
| } |
| """); |
| var container = ensure(compiler, "Class", compiler.coreLibrary.find, |
| expectIsPatched: true); |
| container.parseNode(compiler); |
| |
| print('testPatchNonExternalMember.errors:${compiler.errors}'); |
| print('testPatchNonExternalMember.warnings:${compiler.warnings}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXTERNAL); |
| Expect.equals(1, compiler.warnings.length); |
| Expect.isTrue( |
| compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_FUNCTION); |
| } |
| |
| testPatchNonClass() { |
| var compiler = applyPatch( |
| """ |
| external void Class() {} |
| """, |
| """ |
| patch class Class {} |
| """); |
| print('testPatchNonClass.errors:${compiler.errors}'); |
| print('testPatchNonClass.warnings:${compiler.warnings}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == MessageKind.PATCH_NON_CLASS); |
| Expect.equals(1, compiler.warnings.length); |
| Expect.isTrue( |
| compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_CLASS); |
| } |
| |
| testPatchNonGetter() { |
| var compiler = applyPatch( |
| """ |
| external void foo() {} |
| """, |
| """ |
| patch get foo => 0; |
| """); |
| print('testPatchNonClass.errors:${compiler.errors}'); |
| print('testPatchNonClass.warnings:${compiler.warnings}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == MessageKind.PATCH_NON_GETTER); |
| Expect.equals(1, compiler.warnings.length); |
| Expect.isTrue( |
| compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_GETTER); |
| } |
| |
| testPatchNoGetter() { |
| var compiler = applyPatch( |
| """ |
| external set foo(var value) {} |
| """, |
| """ |
| patch get foo => 0; |
| """); |
| print('testPatchNonClass.errors:${compiler.errors}'); |
| print('testPatchNonClass.warnings:${compiler.warnings}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == MessageKind.PATCH_NO_GETTER); |
| Expect.equals(1, compiler.warnings.length); |
| Expect.isTrue( |
| compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_GETTER); |
| } |
| |
| testPatchNonSetter() { |
| var compiler = applyPatch( |
| """ |
| external void foo() {} |
| """, |
| """ |
| patch set foo(var value) {} |
| """); |
| print('testPatchNonClass.errors:${compiler.errors}'); |
| print('testPatchNonClass.warnings:${compiler.warnings}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == MessageKind.PATCH_NON_SETTER); |
| Expect.equals(1, compiler.warnings.length); |
| Expect.isTrue( |
| compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_SETTER); |
| } |
| |
| testPatchNoSetter() { |
| var compiler = applyPatch( |
| """ |
| external get foo; |
| """, |
| """ |
| patch set foo(var value) {} |
| """); |
| print('testPatchNonClass.errors:${compiler.errors}'); |
| print('testPatchNonClass.warnings:${compiler.warnings}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == MessageKind.PATCH_NO_SETTER); |
| Expect.equals(1, compiler.warnings.length); |
| Expect.isTrue( |
| compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_SETTER); |
| } |
| |
| testPatchNonFunction() { |
| var compiler = applyPatch( |
| """ |
| external get foo; |
| """, |
| """ |
| patch void foo() {} |
| """); |
| print('testPatchNonClass.errors:${compiler.errors}'); |
| print('testPatchNonClass.warnings:${compiler.warnings}'); |
| Expect.equals(1, compiler.errors.length); |
| Expect.isTrue( |
| compiler.errors[0].message.kind == MessageKind.PATCH_NON_FUNCTION); |
| Expect.equals(1, compiler.warnings.length); |
| Expect.isTrue( |
| compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_FUNCTION); |
| } |
| |
| testPatchAndSelector() { |
| var compiler = applyPatch( |
| """ |
| class A { |
| external void clear(); |
| } |
| class B extends A { |
| } |
| """, |
| """ |
| patch class A { |
| int method() => 0; |
| patch void clear() {} |
| } |
| """); |
| ClassElement cls = ensure(compiler, "A", compiler.coreLibrary.find, |
| expectIsPatched: true); |
| cls.ensureResolved(compiler); |
| |
| ensure(compiler, "method", cls.patch.lookupLocalMember, |
| checkHasBody: true, expectIsRegular: true); |
| |
| ensure(compiler, "clear", cls.lookupLocalMember, |
| checkHasBody: true, expectIsPatched: true); |
| |
| compiler.phase = Compiler.PHASE_DONE_RESOLVING; |
| |
| // Check that a method just in the patch class is a target for a |
| // typed selector. |
| var selector = new Selector.call( |
| buildSourceString('method'), compiler.coreLibrary, 0); |
| var typedSelector = new TypedSelector.exact(cls.rawType, selector); |
| Element method = |
| cls.implementation.lookupLocalMember(buildSourceString('method')); |
| Expect.isTrue(selector.applies(method, compiler)); |
| Expect.isTrue(typedSelector.applies(method, compiler)); |
| |
| // Check that the declaration method in the declaration class is a target |
| // for a typed selector. |
| selector = new Selector.call( |
| buildSourceString('clear'), compiler.coreLibrary, 0); |
| typedSelector = new TypedSelector.exact(cls.rawType, selector); |
| method = cls.lookupLocalMember(buildSourceString('clear')); |
| Expect.isTrue(selector.applies(method, compiler)); |
| Expect.isTrue(typedSelector.applies(method, compiler)); |
| |
| // Check that the declaration method in the declaration class is a target |
| // for a typed selector on a subclass. |
| cls = ensure(compiler, "B", compiler.coreLibrary.find); |
| cls.ensureResolved(compiler); |
| typedSelector = new TypedSelector.exact(cls.rawType, selector); |
| Expect.isTrue(selector.applies(method, compiler)); |
| Expect.isTrue(typedSelector.applies(method, compiler)); |
| } |
| |
| main() { |
| testPatchConstructor(); |
| testPatchFunction(); |
| testPatchMember(); |
| testPatchGetter(); |
| testRegularMember(); |
| testGhostMember(); |
| testInjectFunction(); |
| testPatchSignatureCheck(); |
| |
| testExternalWithoutImplementationTopLevel(); |
| testExternalWithoutImplementationMember(); |
| |
| testIsSubclass(); |
| |
| testPatchNonExistingTopLevel(); |
| testPatchNonExistingMember(); |
| testPatchNonPatchablePatch(); |
| testPatchNonPatchableOrigin(); |
| testPatchNonExternalTopLevel(); |
| testPatchNonExternalMember(); |
| testPatchNonClass(); |
| testPatchNonGetter(); |
| testPatchNoGetter(); |
| testPatchNonSetter(); |
| testPatchNoSetter(); |
| testPatchNonFunction(); |
| |
| testPatchAndSelector(); |
| } |
