johnniwinther@google.com
c5a83b2061
Review URL: https://codereview.chromium.org//11864010 git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@18137 260f80e4-7a28-3924-810f-c04153c831b5
727 lines
23 KiB
Dart
727 lines
23 KiB
Dart
// 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 "../../../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);
|
|
}
|
|
|
|
main() {
|
|
testPatchConstructor();
|
|
testPatchFunction();
|
|
testPatchMember();
|
|
testPatchGetter();
|
|
testRegularMember();
|
|
testGhostMember();
|
|
testInjectFunction();
|
|
testPatchSignatureCheck();
|
|
|
|
testExternalWithoutImplementationTopLevel();
|
|
testExternalWithoutImplementationMember();
|
|
|
|
testIsSubclass();
|
|
|
|
testPatchNonExistingTopLevel();
|
|
testPatchNonExistingMember();
|
|
testPatchNonPatchablePatch();
|
|
testPatchNonPatchableOrigin();
|
|
testPatchNonExternalTopLevel();
|
|
testPatchNonExternalMember();
|
|
testPatchNonClass();
|
|
testPatchNonGetter();
|
|
testPatchNoGetter();
|
|
testPatchNonSetter();
|
|
testPatchNoSetter();
|
|
testPatchNonFunction();
|
|
}
|