| // Copyright (c) 2016, 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:kernel/ast.dart'; |
| import 'package:kernel/text/ast_to_text.dart'; |
| import 'package:kernel/verifier.dart'; |
| import 'package:test/test.dart'; |
| |
| /// Checks that the verifier correctly find errors in invalid programs. |
| /// |
| /// The frontend should never generate invalid programs, so we have to test |
| /// these by manually constructing invalid ASTs. |
| /// |
| /// We mostly test negative cases here, as we get plenty of positive cases by |
| /// compiling the Dart test suite with the verifier enabled. |
| main() { |
| positiveTest('Test harness has no errors', (TestHarness test) { |
| return new NullLiteral(); |
| }); |
| negativeTest('VariableGet out of scope', (TestHarness test) { |
| return new VariableGet(test.makeVariable()); |
| }); |
| negativeTest('VariableSet out of scope', (TestHarness test) { |
| return new VariableSet(test.makeVariable(), new NullLiteral()); |
| }); |
| negativeTest('Variable block scope', (TestHarness test) { |
| VariableDeclaration variable = test.makeVariable(); |
| return new Block([ |
| new Block([variable]), |
| new ReturnStatement(new VariableGet(variable)) |
| ]); |
| }); |
| negativeTest('Variable let scope', (TestHarness test) { |
| VariableDeclaration variable = test.makeVariable(); |
| return new LogicalExpression(new Let(variable, new VariableGet(variable)), |
| '&&', new VariableGet(variable)); |
| }); |
| negativeTest('Variable redeclared', (TestHarness test) { |
| VariableDeclaration variable = test.makeVariable(); |
| return new Block([variable, variable]); |
| }); |
| negativeTest('Member redeclared', (TestHarness test) { |
| Field field = new Field(new Name('field'), initializer: new NullLiteral()); |
| return new Class( |
| name: 'Test', |
| supertype: test.objectClass.asRawSupertype, |
| fields: [field, field]); |
| }); |
| negativeTest('Class redeclared', (TestHarness test) { |
| return test.otherClass; // Test harness also adds otherClass to program. |
| }); |
| negativeTest('Class type parameter redeclared', (TestHarness test) { |
| var parameter = test.makeTypeParameter(); |
| return new Class( |
| name: 'Test', |
| supertype: test.objectClass.asRawSupertype, |
| typeParameters: [parameter, parameter]); |
| }); |
| negativeTest('Member type parameter redeclared', (TestHarness test) { |
| var parameter = test.makeTypeParameter(); |
| return new Procedure( |
| new Name('bar'), |
| ProcedureKind.Method, |
| new FunctionNode(new ReturnStatement(new NullLiteral()), |
| typeParameters: [parameter, parameter])); |
| }); |
| negativeTest('Type parameter out of scope', (TestHarness test) { |
| var parameter = test.makeTypeParameter(); |
| return new ListLiteral([], typeArgument: new TypeParameterType(parameter)); |
| }); |
| negativeTest('Class type parameter from another class', (TestHarness test) { |
| return new TypeLiteral( |
| new TypeParameterType(test.otherClass.typeParameters[0])); |
| }); |
| negativeTest('Class type parameter in static method', (TestHarness test) { |
| return new Procedure( |
| new Name('bar'), |
| ProcedureKind.Method, |
| new FunctionNode(new ReturnStatement( |
| new TypeLiteral(new TypeParameterType(test.classTypeParameter)))), |
| isStatic: true); |
| }); |
| negativeTest('Class type parameter in static field', (TestHarness test) { |
| return new Field(new Name('field'), |
| initializer: |
| new TypeLiteral(new TypeParameterType(test.classTypeParameter)), |
| isStatic: true); |
| }); |
| negativeTest('Method type parameter out of scope', (TestHarness test) { |
| var parameter = test.makeTypeParameter(); |
| return new Class( |
| name: 'Test', |
| supertype: test.objectClass.asRawSupertype, |
| procedures: [ |
| new Procedure( |
| new Name('generic'), |
| ProcedureKind.Method, |
| new FunctionNode(new EmptyStatement(), |
| typeParameters: [parameter])), |
| new Procedure( |
| new Name('use'), |
| ProcedureKind.Method, |
| new FunctionNode(new ReturnStatement( |
| new TypeLiteral(new TypeParameterType(parameter))))) |
| ]); |
| }); |
| negativeTest('Interface type arity too low', (TestHarness test) { |
| return new TypeLiteral(new InterfaceType(test.otherClass, [])); |
| }); |
| negativeTest('Interface type arity too high', (TestHarness test) { |
| return new TypeLiteral(new InterfaceType( |
| test.otherClass, [new DynamicType(), new DynamicType()])); |
| }); |
| negativeTest('Dangling interface type', (TestHarness test) { |
| var orphan = new Class(); |
| return new TypeLiteral(new InterfaceType(orphan)); |
| }); |
| negativeTest('Dangling field get', (TestHarness test) { |
| var orphan = new Field(new Name('foo')); |
| return new DirectPropertyGet(new NullLiteral(), orphan); |
| }); |
| negativeTest('Missing block parent pointer', (TestHarness test) { |
| var block = new Block([]); |
| block.statements.add(new ReturnStatement()); |
| return block; |
| }); |
| negativeTest('Missing function parent pointer', (TestHarness test) { |
| var procedure = new Procedure(new Name('bar'), ProcedureKind.Method, null); |
| procedure.function = new FunctionNode(new EmptyStatement()); |
| return procedure; |
| }); |
| negativeTest('StaticGet without target', (TestHarness test) { |
| return new StaticGet(null); |
| }); |
| negativeTest('StaticSet without target', (TestHarness test) { |
| return new StaticSet(null, new NullLiteral()); |
| }); |
| negativeTest('StaticInvocation without target', (TestHarness test) { |
| return new StaticInvocation(null, new Arguments.empty()); |
| }); |
| positiveTest('Correct StaticInvocation', (TestHarness test) { |
| var method = new Procedure( |
| new Name('foo'), |
| ProcedureKind.Method, |
| new FunctionNode(new EmptyStatement(), |
| positionalParameters: [new VariableDeclaration('p')]), |
| isStatic: true); |
| test.enclosingClass.addMember(method); |
| return new StaticInvocation(method, new Arguments([new NullLiteral()])); |
| }); |
| negativeTest('StaticInvocation with too many parameters', (TestHarness test) { |
| var method = new Procedure(new Name('bar'), ProcedureKind.Method, |
| new FunctionNode(new EmptyStatement()), |
| isStatic: true); |
| test.enclosingClass.addMember(method); |
| return new StaticInvocation(method, new Arguments([new NullLiteral()])); |
| }); |
| negativeTest('StaticInvocation with too few parameters', (TestHarness test) { |
| var method = new Procedure( |
| new Name('bar'), |
| ProcedureKind.Method, |
| new FunctionNode(new EmptyStatement(), |
| positionalParameters: [new VariableDeclaration('p')]), |
| isStatic: true); |
| test.enclosingClass.addMember(method); |
| return new StaticInvocation(method, new Arguments.empty()); |
| }); |
| negativeTest('StaticInvocation with unmatched named parameter', |
| (TestHarness test) { |
| var method = new Procedure(new Name('bar'), ProcedureKind.Method, |
| new FunctionNode(new EmptyStatement()), |
| isStatic: true); |
| test.enclosingClass.addMember(method); |
| return new StaticInvocation( |
| method, |
| new Arguments([], |
| named: [new NamedExpression('p', new NullLiteral())])); |
| }); |
| negativeTest('StaticInvocation with missing type argument', |
| (TestHarness test) { |
| var method = new Procedure( |
| new Name('bar'), |
| ProcedureKind.Method, |
| new FunctionNode(new EmptyStatement(), |
| typeParameters: [test.makeTypeParameter()]), |
| isStatic: true); |
| test.enclosingClass.addMember(method); |
| return new StaticInvocation(method, new Arguments.empty()); |
| }); |
| negativeTest('ConstructorInvocation with missing type argument', |
| (TestHarness test) { |
| var class_ = new Class( |
| name: 'Test', |
| typeParameters: [test.makeTypeParameter()], |
| supertype: test.objectClass.asRawSupertype); |
| test.enclosingLibrary.addClass(class_); |
| var constructor = new Constructor(new FunctionNode(new EmptyStatement()), |
| name: new Name('foo')); |
| test.enclosingClass.addMember(constructor); |
| return new ConstructorInvocation(constructor, new Arguments.empty()); |
| }); |
| } |
| |
| checkHasError(Program program) { |
| bool passed = false; |
| try { |
| verifyProgram(program); |
| passed = true; |
| } catch (e) {} |
| if (passed) { |
| fail('Failed to reject invalid program:\n${programToString(program)}'); |
| } |
| } |
| |
| class TestHarness { |
| Program program; |
| Class objectClass; |
| Library stubLibrary; |
| |
| TypeParameter classTypeParameter; |
| |
| Library enclosingLibrary; |
| Class enclosingClass; |
| Procedure enclosingMember; |
| |
| Class otherClass; |
| |
| void addNode(TreeNode node) { |
| if (node is Expression) { |
| addExpression(node); |
| } else if (node is Statement) { |
| addStatement(node); |
| } else if (node is Member) { |
| addClassMember(node); |
| } else if (node is Class) { |
| addClass(node); |
| } |
| } |
| |
| void addExpression(Expression node) { |
| addStatement(new ReturnStatement(node)); |
| } |
| |
| void addStatement(Statement node) { |
| var function = enclosingMember.function; |
| function.body = node..parent = function; |
| } |
| |
| void addClassMember(Member node) { |
| enclosingClass.addMember(node); |
| } |
| |
| void addTopLevelMember(Member node) { |
| enclosingLibrary.addMember(node); |
| } |
| |
| void addClass(Class node) { |
| enclosingLibrary.addClass(node); |
| } |
| |
| VariableDeclaration makeVariable() => new VariableDeclaration(null); |
| |
| TypeParameter makeTypeParameter([String name]) { |
| return new TypeParameter(name, new InterfaceType(objectClass)); |
| } |
| |
| TestHarness() { |
| setupProgram(); |
| } |
| |
| void setupProgram() { |
| program = new Program(); |
| stubLibrary = new Library(Uri.parse('dart:core')); |
| program.libraries.add(stubLibrary..parent = program); |
| stubLibrary.name = 'dart.core'; |
| objectClass = new Class(name: 'Object'); |
| stubLibrary.addClass(objectClass); |
| enclosingLibrary = new Library(Uri.parse('file://test.dart')); |
| program.libraries.add(enclosingLibrary..parent = program); |
| enclosingLibrary.name = 'test_lib'; |
| classTypeParameter = makeTypeParameter('T'); |
| enclosingClass = new Class( |
| name: 'TestClass', |
| typeParameters: [classTypeParameter], |
| supertype: objectClass.asRawSupertype); |
| enclosingLibrary.addClass(enclosingClass); |
| enclosingMember = new Procedure(new Name('test'), ProcedureKind.Method, |
| new FunctionNode(new EmptyStatement())); |
| enclosingClass.addMember(enclosingMember); |
| otherClass = new Class( |
| name: 'OtherClass', |
| typeParameters: [makeTypeParameter('OtherT')], |
| supertype: objectClass.asRawSupertype); |
| enclosingLibrary.addClass(otherClass); |
| } |
| } |
| |
| negativeTest(String name, TreeNode makeTestCase(TestHarness test)) { |
| test(name, () { |
| var test = new TestHarness(); |
| test.addNode(makeTestCase(test)); |
| checkHasError(test.program); |
| }); |
| } |
| |
| positiveTest(String name, TreeNode makeTestCase(TestHarness test)) { |
| test(name, () { |
| var test = new TestHarness(); |
| test.addNode(makeTestCase(test)); |
| verifyProgram(test.program); |
| }); |
| } |