languages/dart-sdk
languages/dart-sdk
1
0
Fork 0
mirror of https://github.com/dart-lang/sdk synced 2024-10-14 08:51:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

[kernel] Add always_declare_return_types lint

Browse source 
Change-Id: Icdcc648f42393b28daf648f752e3b4d61f51aa10
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/212043
Commit-Queue: Johnni Winther <johnniwinther@google.com>
Reviewed-by: Jens Johansen <jensj@google.com>
This commit is contained in:
Johnni Winther 2021-09-01 16:50:27 +00:00 committed by commit-bot@chromium.org
parent 4bd4de0eb9
commit 4ff04f641b
65 changed files with 441 additions and 465 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
pkg/kernel/analysis_options.yaml
View file

@ -17,4 +17,5 @@ linter:
- lines_longer_than_80_chars
- unrelated_type_equality_checks
- annotate_overrides
- always_declare_return_types
# - always_specify_types

6
pkg/kernel/bin/count_breakdown.dart
View file

@ -17,7 +17,7 @@ void usage() {
exit(1);
}
main(List<String> args) {
void main(List<String> args) {
CommandLineHelper.requireExactlyOneArgument(args, usage,
requireFileExists: true);
Component component = CommandLineHelper.tryLoadDill(args[0]);
@ -30,13 +30,13 @@ class TypeCounter extends RecursiveVisitor {
Map<String, int> _typeCounts = <String, int>{};
@override
defaultNode(Node node) {
void defaultNode(Node node) {
String key = node.runtimeType.toString();
_typeCounts[key] = (_typeCounts[key] ??= 0) + 1;
super.defaultNode(node);
}
printStats() {
void printStats() {
List<List<Object>> data = [];
_typeCounts.forEach((type, count) {
data.add([type, count]);

2
pkg/kernel/bin/dill_forensic.dart
View file

@ -10,7 +10,7 @@ import 'package:kernel/kernel.dart'
show Component, Source, loadComponentFromBytes;
import 'package:kernel/binary/tag.dart' show Tag;
main(List<String> args) {
void main(List<String> args) {
if (args.length != 1) {
throw "Usage: dart <script> <dillfile>";
}

2
pkg/kernel/bin/dump.dart
View file

@ -22,7 +22,7 @@ void usage() {
exit(1);
}
main(List<String> args) {
void main(List<String> args) {
CommandLineHelper.requireVariableArgumentCount([1, 2], args, usage);
CommandLineHelper.requireFileExists(args[0]);
var binary = CommandLineHelper.tryLoadDill(args[0]);

2
pkg/kernel/bin/size_breakdown.dart
View file

@ -19,7 +19,7 @@ void usage() {
exit(1);
}
main(args) {
void main(args) {
CommandLineHelper.requireExactlyOneArgument(args, usage,
requireFileExists: true);
List<int> bytes = new File(args[0]).readAsBytesSync();

2
pkg/kernel/bin/split.dart
View file

@ -21,7 +21,7 @@ void usage() {
exit(1);
}
main(args) async {
void main(args) async {
CommandLineHelper.requireExactlyOneArgument(args, usage,
requireFileExists: true);
Component binary = CommandLineHelper.tryLoadDill(args[0]);

4
pkg/kernel/lib/ast.dart
View file

@ -12129,7 +12129,7 @@ class Supertype extends Node {
R accept1<R, A>(Visitor1<R, A> v, A arg) => v.visitSupertype(this, arg);
@override
visitChildren(Visitor v) {
void visitChildren(Visitor v) {
classNode.acceptReference(v);
visitList(typeArguments, v);
}
@ -12690,7 +12690,7 @@ class InstanceConstant extends Constant {
Class get classNode => classReference.asClass;
@override
visitChildren(Visitor v) {
void visitChildren(Visitor v) {
classReference.asClass.acceptReference(v);
visitList(typeArguments, v);
for (final Reference reference in fieldValues.keys) {

2
pkg/kernel/lib/binary/ast_from_binary.dart
View file

@ -183,7 +183,7 @@ class BinaryBuilder {
(alwaysCreateNewNamedNodes == true),
this.alwaysCreateNewNamedNodes = alwaysCreateNewNamedNodes ?? false;
fail(String message) {
Never fail(String message) {
throw ParseError(message,
byteIndex: _byteOffset, filename: filename, path: debugPath.join('::'));
}

10
pkg/kernel/lib/binary/ast_to_binary.dart
View file

@ -990,7 +990,7 @@ class BinaryPrinter implements Visitor<void>, BinarySink {
writeNullAllowedCanonicalNameReference(node.reference.canonicalName);
}
writeOffset(int offset) {
void writeOffset(int offset) {
// TODO(jensj): Delta-encoding.
// File offset ranges from -1 and up,
// but is here saved as unsigned (thus the +1)
@ -1867,7 +1867,7 @@ class BinaryPrinter implements Visitor<void>, BinarySink {
writeInteger(node.value);
}
writeInteger(int value) {
void writeInteger(int value) {
int biasedValue = value + Tag.SpecializedIntLiteralBias;
if (biasedValue >= 0 &&
biasedValue & Tag.SpecializedPayloadMask == biasedValue) {
@ -1893,7 +1893,7 @@ class BinaryPrinter implements Visitor<void>, BinarySink {
writeDouble(node.value);
}
writeDouble(double value) {
void writeDouble(double value) {
_sink.addDouble(value);
}
@ -2024,7 +2024,7 @@ class BinaryPrinter implements Visitor<void>, BinarySink {
writeLibraryDependencyReference(node.import);
}
writeStatementOrEmpty(Statement? node) {
void writeStatementOrEmpty(Statement? node) {
if (node == null) {
writeByte(Tag.EmptyStatement);
} else {
@ -2858,7 +2858,7 @@ class ConstantIndexer extends RecursiveResultVisitor {
}
@override
defaultConstantReference(Constant node) {
void defaultConstantReference(Constant node) {
put(node);
}
}

172
pkg/kernel/lib/clone.dart
View file

@ -159,111 +159,111 @@ class CloneVisitorNotMembers implements TreeVisitor<TreeNode> {
}
@override
visitInvalidExpression(InvalidExpression node) {
TreeNode visitInvalidExpression(InvalidExpression node) {
return new InvalidExpression(
node.message, node.expression != null ? clone(node.expression!) : null);
}
@override
visitVariableGet(VariableGet node) {
TreeNode visitVariableGet(VariableGet node) {
return new VariableGet(
getVariableClone(node.variable)!, visitOptionalType(node.promotedType));
}
@override
visitVariableSet(VariableSet node) {
TreeNode visitVariableSet(VariableSet node) {
return new VariableSet(getVariableClone(node.variable)!, clone(node.value));
}
@override
visitSuperPropertyGet(SuperPropertyGet node) {
TreeNode visitSuperPropertyGet(SuperPropertyGet node) {
return new SuperPropertyGet.byReference(
node.name, node.interfaceTargetReference);
}
@override
visitSuperPropertySet(SuperPropertySet node) {
TreeNode visitSuperPropertySet(SuperPropertySet node) {
return new SuperPropertySet.byReference(
node.name, clone(node.value), node.interfaceTargetReference);
}
@override
visitStaticGet(StaticGet node) {
TreeNode visitStaticGet(StaticGet node) {
return new StaticGet.byReference(node.targetReference);
}
@override
visitStaticSet(StaticSet node) {
TreeNode visitStaticSet(StaticSet node) {
return new StaticSet.byReference(node.targetReference, clone(node.value));
}
@override
visitSuperMethodInvocation(SuperMethodInvocation node) {
TreeNode visitSuperMethodInvocation(SuperMethodInvocation node) {
return new SuperMethodInvocation.byReference(
node.name, clone(node.arguments), node.interfaceTargetReference);
}
@override
visitStaticInvocation(StaticInvocation node) {
TreeNode visitStaticInvocation(StaticInvocation node) {
return new StaticInvocation.byReference(
node.targetReference, clone(node.arguments),
isConst: node.isConst);
}
@override
visitConstructorInvocation(ConstructorInvocation node) {
TreeNode visitConstructorInvocation(ConstructorInvocation node) {
return new ConstructorInvocation.byReference(
node.targetReference, clone(node.arguments),
isConst: node.isConst);
}
@override
visitNot(Not node) {
TreeNode visitNot(Not node) {
return new Not(clone(node.operand));
}
@override
visitNullCheck(NullCheck node) {
TreeNode visitNullCheck(NullCheck node) {
return new NullCheck(clone(node.operand));
}
@override
visitLogicalExpression(LogicalExpression node) {
TreeNode visitLogicalExpression(LogicalExpression node) {
return new LogicalExpression(
clone(node.left), node.operatorEnum, clone(node.right));
}
@override
visitConditionalExpression(ConditionalExpression node) {
TreeNode visitConditionalExpression(ConditionalExpression node) {
return new ConditionalExpression(clone(node.condition), clone(node.then),
clone(node.otherwise), visitType(node.staticType));
}
@override
visitStringConcatenation(StringConcatenation node) {
TreeNode visitStringConcatenation(StringConcatenation node) {
return new StringConcatenation(node.expressions.map(clone).toList());
}
@override
visitListConcatenation(ListConcatenation node) {
TreeNode visitListConcatenation(ListConcatenation node) {
return new ListConcatenation(node.lists.map(clone).toList(),
typeArgument: visitType(node.typeArgument));
}
@override
visitSetConcatenation(SetConcatenation node) {
TreeNode visitSetConcatenation(SetConcatenation node) {
return new SetConcatenation(node.sets.map(clone).toList(),
typeArgument: visitType(node.typeArgument));
}
@override
visitMapConcatenation(MapConcatenation node) {
TreeNode visitMapConcatenation(MapConcatenation node) {
return new MapConcatenation(node.maps.map(clone).toList(),
keyType: visitType(node.keyType), valueType: visitType(node.valueType));
}
@override
visitInstanceCreation(InstanceCreation node) {
TreeNode visitInstanceCreation(InstanceCreation node) {
final Map<Reference, Expression> fieldValues = <Reference, Expression>{};
node.fieldValues.forEach((Reference fieldRef, Expression value) {
fieldValues[fieldRef] = clone(value);
@ -277,61 +277,61 @@ class CloneVisitorNotMembers implements TreeVisitor<TreeNode> {
}
@override
visitFileUriExpression(FileUriExpression node) {
TreeNode visitFileUriExpression(FileUriExpression node) {
return new FileUriExpression(clone(node.expression), _activeFileUri!);
}
@override
visitIsExpression(IsExpression node) {
TreeNode visitIsExpression(IsExpression node) {
return new IsExpression(clone(node.operand), visitType(node.type))
..flags = node.flags;
}
@override
visitAsExpression(AsExpression node) {
TreeNode visitAsExpression(AsExpression node) {
return new AsExpression(clone(node.operand), visitType(node.type))
..flags = node.flags;
}
@override
visitSymbolLiteral(SymbolLiteral node) {
TreeNode visitSymbolLiteral(SymbolLiteral node) {
return new SymbolLiteral(node.value);
}
@override
visitTypeLiteral(TypeLiteral node) {
TreeNode visitTypeLiteral(TypeLiteral node) {
return new TypeLiteral(visitType(node.type));
}
@override
visitThisExpression(ThisExpression node) {
TreeNode visitThisExpression(ThisExpression node) {
return new ThisExpression();
}
@override
visitRethrow(Rethrow node) {
TreeNode visitRethrow(Rethrow node) {
return new Rethrow();
}
@override
visitThrow(Throw node) {
TreeNode visitThrow(Throw node) {
return new Throw(clone(node.expression));
}
@override
visitListLiteral(ListLiteral node) {
TreeNode visitListLiteral(ListLiteral node) {
return new ListLiteral(node.expressions.map(clone).toList(),
typeArgument: visitType(node.typeArgument), isConst: node.isConst);
}
@override
visitSetLiteral(SetLiteral node) {
TreeNode visitSetLiteral(SetLiteral node) {
return new SetLiteral(node.expressions.map(clone).toList(),
typeArgument: visitType(node.typeArgument), isConst: node.isConst);
}
@override
visitMapLiteral(MapLiteral node) {
TreeNode visitMapLiteral(MapLiteral node) {
return new MapLiteral(node.entries.map(clone).toList(),
keyType: visitType(node.keyType),
valueType: visitType(node.valueType),
@ -339,85 +339,85 @@ class CloneVisitorNotMembers implements TreeVisitor<TreeNode> {
}
@override
visitMapLiteralEntry(MapLiteralEntry node) {
TreeNode visitMapLiteralEntry(MapLiteralEntry node) {
return new MapLiteralEntry(clone(node.key), clone(node.value));
}
@override
visitAwaitExpression(AwaitExpression node) {
TreeNode visitAwaitExpression(AwaitExpression node) {
return new AwaitExpression(clone(node.operand));
}
@override
visitFunctionExpression(FunctionExpression node) {
TreeNode visitFunctionExpression(FunctionExpression node) {
return new FunctionExpression(clone(node.function));
}
@override
visitConstantExpression(ConstantExpression node) {
TreeNode visitConstantExpression(ConstantExpression node) {
return new ConstantExpression(
visitConstant(node.constant), visitType(node.type));
}
@override
visitStringLiteral(StringLiteral node) {
TreeNode visitStringLiteral(StringLiteral node) {
return new StringLiteral(node.value);
}
@override
visitIntLiteral(IntLiteral node) {
TreeNode visitIntLiteral(IntLiteral node) {
return new IntLiteral(node.value);
}
@override
visitDoubleLiteral(DoubleLiteral node) {
TreeNode visitDoubleLiteral(DoubleLiteral node) {
return new DoubleLiteral(node.value);
}
@override
visitBoolLiteral(BoolLiteral node) {
TreeNode visitBoolLiteral(BoolLiteral node) {
return new BoolLiteral(node.value);
}
@override
visitNullLiteral(NullLiteral node) {
TreeNode visitNullLiteral(NullLiteral node) {
return new NullLiteral();
}
@override
visitLet(Let node) {
TreeNode visitLet(Let node) {
VariableDeclaration newVariable = clone(node.variable);
return new Let(newVariable, clone(node.body));
}
@override
visitBlockExpression(BlockExpression node) {
TreeNode visitBlockExpression(BlockExpression node) {
return new BlockExpression(clone(node.body), clone(node.value));
}
@override
visitExpressionStatement(ExpressionStatement node) {
TreeNode visitExpressionStatement(ExpressionStatement node) {
return new ExpressionStatement(clone(node.expression));
}
@override
visitBlock(Block node) {
TreeNode visitBlock(Block node) {
return new Block(node.statements.map(clone).toList())
..fileEndOffset = _cloneFileOffset(node.fileEndOffset);
}
@override
visitAssertBlock(AssertBlock node) {
TreeNode visitAssertBlock(AssertBlock node) {
return new AssertBlock(node.statements.map(clone).toList());
}
@override
visitEmptyStatement(EmptyStatement node) {
TreeNode visitEmptyStatement(EmptyStatement node) {
return new EmptyStatement();
}
@override
visitAssertStatement(AssertStatement node) {
TreeNode visitAssertStatement(AssertStatement node) {
return new AssertStatement(clone(node.condition),
conditionStartOffset: node.conditionStartOffset,
conditionEndOffset: node.conditionEndOffset,
@ -425,7 +425,7 @@ class CloneVisitorNotMembers implements TreeVisitor<TreeNode> {
}
@override
visitLabeledStatement(LabeledStatement node) {
TreeNode visitLabeledStatement(LabeledStatement node) {
LabeledStatement newNode = new LabeledStatement(null);
labels[node] = newNode;
newNode.body = clone(node.body)..parent = newNode;
@ -433,29 +433,29 @@ class CloneVisitorNotMembers implements TreeVisitor<TreeNode> {
}
@override
visitBreakStatement(BreakStatement node) {
TreeNode visitBreakStatement(BreakStatement node) {
return new BreakStatement(labels[node.target]!);
}
@override
visitWhileStatement(WhileStatement node) {
TreeNode visitWhileStatement(WhileStatement node) {
return new WhileStatement(clone(node.condition), clone(node.body));
}
@override
visitDoStatement(DoStatement node) {
TreeNode visitDoStatement(DoStatement node) {
return new DoStatement(clone(node.body), clone(node.condition));
}
@override
visitForStatement(ForStatement node) {
TreeNode visitForStatement(ForStatement node) {
List<VariableDeclaration> variables = node.variables.map(clone).toList();
return new ForStatement(variables, cloneOptional(node.condition),
node.updates.map(clone).toList(), clone(node.body));
}
@override
visitForInStatement(ForInStatement node) {
TreeNode visitForInStatement(ForInStatement node) {
VariableDeclaration newVariable = clone(node.variable);
return new ForInStatement(
newVariable, clone(node.iterable), clone(node.body),
@ -464,7 +464,7 @@ class CloneVisitorNotMembers implements TreeVisitor<TreeNode> {
}
@override
visitSwitchStatement(SwitchStatement node) {
TreeNode visitSwitchStatement(SwitchStatement node) {
for (SwitchCase switchCase in node.cases) {
switchCases[switchCase] = new SwitchCase(
switchCase.expressions.map(clone).toList(),
@ -477,36 +477,36 @@ class CloneVisitorNotMembers implements TreeVisitor<TreeNode> {
}
@override
visitSwitchCase(SwitchCase node) {
TreeNode visitSwitchCase(SwitchCase node) {
SwitchCase switchCase = switchCases[node]!;
switchCase.body = clone(node.body)..parent = switchCase;
return switchCase;
}
@override
visitContinueSwitchStatement(ContinueSwitchStatement node) {
TreeNode visitContinueSwitchStatement(ContinueSwitchStatement node) {
return new ContinueSwitchStatement(switchCases[node.target]!);
}
@override
visitIfStatement(IfStatement node) {
TreeNode visitIfStatement(IfStatement node) {
return new IfStatement(
clone(node.condition), clone(node.then), cloneOptional(node.otherwise));
}
@override
visitReturnStatement(ReturnStatement node) {
TreeNode visitReturnStatement(ReturnStatement node) {
return new ReturnStatement(cloneOptional(node.expression));
}
@override
visitTryCatch(TryCatch node) {
TreeNode visitTryCatch(TryCatch node) {
return new TryCatch(clone(node.body), node.catches.map(clone).toList(),
isSynthetic: node.isSynthetic);
}
@override
visitCatch(Catch node) {
TreeNode visitCatch(Catch node) {
VariableDeclaration? newException = cloneOptional(node.exception);
VariableDeclaration? newStackTrace = cloneOptional(node.stackTrace);
return new Catch(newException, clone(node.body),
@ -514,17 +514,17 @@ class CloneVisitorNotMembers implements TreeVisitor<TreeNode> {
}
@override
visitTryFinally(TryFinally node) {
TreeNode visitTryFinally(TryFinally node) {
return new TryFinally(clone(node.body), clone(node.finalizer));
}
@override
visitYieldStatement(YieldStatement node) {
TreeNode visitYieldStatement(YieldStatement node) {
return new YieldStatement(clone(node.expression))..flags = node.flags;
}
@override
visitVariableDeclaration(VariableDeclaration node) {
TreeNode visitVariableDeclaration(VariableDeclaration node) {
return setVariableClone(
node,
new VariableDeclaration(node.name,
@ -538,7 +538,7 @@ class CloneVisitorNotMembers implements TreeVisitor<TreeNode> {
}
@override
visitFunctionDeclaration(FunctionDeclaration node) {
TreeNode visitFunctionDeclaration(FunctionDeclaration node) {
VariableDeclaration newVariable = clone(node.variable);
// Create the declaration before cloning the body to support recursive
// [LocalFunctionInvocation] nodes.
@ -587,7 +587,7 @@ class CloneVisitorNotMembers implements TreeVisitor<TreeNode> {
}
@override
visitFunctionNode(FunctionNode node) {
TreeNode visitFunctionNode(FunctionNode node) {
prepareTypeParameters(node.typeParameters);
List<TypeParameter> typeParameters =
node.typeParameters.map(clone).toList();
@ -606,119 +606,119 @@ class CloneVisitorNotMembers implements TreeVisitor<TreeNode> {
}
@override
visitArguments(Arguments node) {
TreeNode visitArguments(Arguments node) {
return new Arguments(node.positional.map(clone).toList(),
types: node.types.map(visitType).toList(),
named: node.named.map(clone).toList());
}
@override
visitNamedExpression(NamedExpression node) {
TreeNode visitNamedExpression(NamedExpression node) {
return new NamedExpression(node.name, clone(node.value));
}
@override
defaultBasicLiteral(BasicLiteral node) {
TreeNode defaultBasicLiteral(BasicLiteral node) {
return defaultExpression(node);
}
@override
defaultExpression(Expression node) {
TreeNode defaultExpression(Expression node) {
throw 'Unimplemented clone for Kernel expression: $node';
}
@override
defaultInitializer(Initializer node) {
TreeNode defaultInitializer(Initializer node) {
throw 'Unimplemented clone for Kernel initializer: $node';
}
@override
defaultMember(Member node) {
TreeNode defaultMember(Member node) {
throw 'Unimplemented clone for Kernel member: $node';
}
@override
defaultStatement(Statement node) {
TreeNode defaultStatement(Statement node) {
throw 'Unimplemented clone for Kernel statement: $node';
}
@override
defaultTreeNode(TreeNode node) {
TreeNode defaultTreeNode(TreeNode node) {
throw 'Cloning Kernel non-members is not supported. '
'Tried cloning $node';
}
@override
visitAssertInitializer(AssertInitializer node) {
TreeNode visitAssertInitializer(AssertInitializer node) {
return new AssertInitializer(clone(node.statement));
}
@override
visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) {
TreeNode visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) {
return new CheckLibraryIsLoaded(node.import);
}
@override
visitCombinator(Combinator node) {
TreeNode visitCombinator(Combinator node) {
return defaultTreeNode(node);
}
@override
visitFieldInitializer(FieldInitializer node) {
TreeNode visitFieldInitializer(FieldInitializer node) {
return new FieldInitializer.byReference(
node.fieldReference, clone(node.value));
}
@override
visitInstantiation(Instantiation node) {
TreeNode visitInstantiation(Instantiation node) {
return new Instantiation(
clone(node.expression), node.typeArguments.map(visitType).toList());
}
@override
visitInvalidInitializer(InvalidInitializer node) {
TreeNode visitInvalidInitializer(InvalidInitializer node) {
return new InvalidInitializer();
}
@override
visitLibraryDependency(LibraryDependency node) {
TreeNode visitLibraryDependency(LibraryDependency node) {
return defaultTreeNode(node);
}
@override
visitLibraryPart(LibraryPart node) {
TreeNode visitLibraryPart(LibraryPart node) {
return defaultTreeNode(node);
}
@override
visitLoadLibrary(LoadLibrary node) {
TreeNode visitLoadLibrary(LoadLibrary node) {
return new LoadLibrary(node.import);
}
@override
visitLocalInitializer(LocalInitializer node) {
TreeNode visitLocalInitializer(LocalInitializer node) {
return new LocalInitializer(clone(node.variable));
}
@override
visitComponent(Component node) {
TreeNode visitComponent(Component node) {
return defaultTreeNode(node);
}
@override
visitRedirectingInitializer(RedirectingInitializer node) {
TreeNode visitRedirectingInitializer(RedirectingInitializer node) {
return new RedirectingInitializer.byReference(
node.targetReference, clone(node.arguments));
}
@override
visitSuperInitializer(SuperInitializer node) {
TreeNode visitSuperInitializer(SuperInitializer node) {
return new SuperInitializer.byReference(
node.targetReference, clone(node.arguments));
}
@override
visitTypedef(Typedef node) {
TreeNode visitTypedef(Typedef node) {
return defaultTreeNode(node);
}

8
pkg/kernel/lib/import_table.dart
View file

@ -106,12 +106,12 @@ class _ImportTableBuilder extends RecursiveVisitor {
}
@override
visitClassReference(Class node) {
void visitClassReference(Class node) {
addLibraryImport(node.enclosingLibrary);
}
@override
visitLibrary(Library node) {
void visitLibrary(Library node) {
super.visitLibrary(node);
for (Reference exportedReference in node.additionalExports) {
addLibraryImport(exportedReference.node!.parent as Library);
@ -119,12 +119,12 @@ class _ImportTableBuilder extends RecursiveVisitor {
}
@override
defaultMemberReference(Member node) {
void defaultMemberReference(Member node) {
addLibraryImport(node.enclosingLibrary);
}
@override
visitName(Name name) {
void visitName(Name name) {
if (name.library != null) {
addLibraryImport(name.library);
}

7
pkg/kernel/lib/src/tool/command_line_util.dart
View file

@ -7,7 +7,8 @@ import 'dart:io';
import 'package:kernel/kernel.dart';
class CommandLineHelper {
static requireExactlyOneArgument(List<String> args, void Function() usage,
static void requireExactlyOneArgument(
List<String> args, void Function() usage,
{bool requireFileExists: false}) {
if (args.length != 1) {
print("Expected exactly 1 argument, got ${args.length}.");
@ -16,7 +17,7 @@ class CommandLineHelper {
if (requireFileExists) CommandLineHelper.requireFileExists(args[0]);
}
static requireVariableArgumentCount(
static void requireVariableArgumentCount(
List<int> ok, List<String> args, void Function() usage) {
if (!ok.contains(args.length)) {
print("Expected the argument count to be one of ${ok}, got "
@ -25,7 +26,7 @@ class CommandLineHelper {
}
}
static requireFileExists(String file) {
static void requireFileExists(String file) {
if (!new File(file).existsSync()) {
print("File $file doesn't exist.");
exit(1);

45
pkg/kernel/lib/testing/type_parser.dart
View file

@ -655,49 +655,20 @@ List<ParsedTypeVariable> parseTypeVariables(String text) {
return result;
}
abstract class DefaultAction<R, A> {
R defaultAction(ParsedType node, A a);
static perform<R, A>(Visitor<R, A> visitor, ParsedType node, A a) {
if (visitor is DefaultAction<R, A>) {
DefaultAction<R, A> defaultAction = visitor as DefaultAction<R, A>;
return defaultAction.defaultAction(node, a);
} else {
return null;
}
}
}
abstract class Visitor<R, A> {
R visitInterfaceType(ParsedInterfaceType node, A a) {
return DefaultAction.perform<R, A>(this, node, a);
}
R visitInterfaceType(ParsedInterfaceType node, A a);
R visitClass(ParsedClass node, A a) {
return DefaultAction.perform<R, A>(this, node, a);
}
R visitClass(ParsedClass node, A a);
R visitExtension(ParsedExtension node, A a) {
return DefaultAction.perform<R, A>(this, node, a);
}
R visitExtension(ParsedExtension node, A a);
R visitTypedef(ParsedTypedef node, A a) {
return DefaultAction.perform<R, A>(this, node, a);
}
R visitTypedef(ParsedTypedef node, A a);
R visitFunctionType(ParsedFunctionType node, A a) {
return DefaultAction.perform<R, A>(this, node, a);
}
R visitFunctionType(ParsedFunctionType node, A a);
R visitVoidType(ParsedVoidType node, A a) {
return DefaultAction.perform<R, A>(this, node, a);
}
R visitVoidType(ParsedVoidType node, A a);
R visitTypeVariable(ParsedTypeVariable node, A a) {
return DefaultAction.perform<R, A>(this, node, a);
}
R visitTypeVariable(ParsedTypeVariable node, A a);
R visitIntersectionType(ParsedIntersectionType node, A a) {
return DefaultAction.perform<R, A>(this, node, a);
}
R visitIntersectionType(ParsedIntersectionType node, A a);
}

302
pkg/kernel/lib/text/ast_to_text.dart
View file

File diff suppressed because it is too large Load diff

8
pkg/kernel/lib/text/debug_printer.dart
View file

@ -49,14 +49,14 @@ class DebugPrinter extends Visitor<void>
}
@override
visitStaticInvocation(StaticInvocation node) {
void visitStaticInvocation(StaticInvocation node) {
openNode(node, '${node.runtimeType}', {'target': '${node.target}'});
node.visitChildren(this);
closeNode();
}
@override
visitArguments(Arguments node) {
void visitArguments(Arguments node) {
openNode(node, '${node.runtimeType}', {
'typeArgs': '${node.types}',
'positionalArgs': '${node.positional}',
@ -67,7 +67,7 @@ class DebugPrinter extends Visitor<void>
}
@override
visitAsExpression(AsExpression node) {
void visitAsExpression(AsExpression node) {
openNode(node, '${node.runtimeType}',
{'operand': '${node.operand}', 'DartType': '${node.type}'});
node.visitChildren(this);
@ -75,7 +75,7 @@ class DebugPrinter extends Visitor<void>
}
@override
visitStringLiteral(StringLiteral node) {
void visitStringLiteral(StringLiteral node) {
openAndCloseNode(node, '${node.runtimeType}', {'value': '${node.value}'});
}

2
pkg/kernel/lib/text/indentation.dart
View file

@ -42,7 +42,7 @@ class Indentation {
/// Calls [f] with one more indentation level, restoring indentation context
/// upon return of [f] and returning its result.
indentBlock(Function f) {
void indentBlock(Function f) {
indentMore();
dynamic result = f();
indentLess();

2
pkg/kernel/lib/transformations/async.dart
View file

@ -630,7 +630,7 @@ class ExpressionLifter extends Transformer {
}
@override
visitFunctionNode(FunctionNode node) {
TreeNode visitFunctionNode(FunctionNode node) {
var nestedRewriter = new RecursiveContinuationRewriter(
continuationRewriter.helper, _staticTypeContext);
return nestedRewriter.transform(node);

17
pkg/kernel/lib/transformations/continuation.dart
View file

@ -100,7 +100,7 @@ class RecursiveContinuationRewriter extends RemovingTransformer {
}
@override
visitField(Field node, TreeNode? removalSentinel) {
TreeNode visitField(Field node, TreeNode? removalSentinel) {
staticTypeContext.enterMember(node);
final result = super.visitField(node, removalSentinel);
staticTypeContext.leaveMember(node);
@ -108,7 +108,7 @@ class RecursiveContinuationRewriter extends RemovingTransformer {
}
@override
visitConstructor(Constructor node, TreeNode? removalSentinel) {
TreeNode visitConstructor(Constructor node, TreeNode? removalSentinel) {
staticTypeContext.enterMember(node);
final result = super.visitConstructor(node, removalSentinel);
staticTypeContext.leaveMember(node);
@ -116,7 +116,7 @@ class RecursiveContinuationRewriter extends RemovingTransformer {
}
@override
visitProcedure(Procedure node, TreeNode? removalSentinel) {
TreeNode visitProcedure(Procedure node, TreeNode? removalSentinel) {
staticTypeContext.enterMember(node);
final result =
node.isAbstract ? node : super.visitProcedure(node, removalSentinel);
@ -125,7 +125,7 @@ class RecursiveContinuationRewriter extends RemovingTransformer {
}
@override
visitLibrary(Library node, TreeNode? removalSentinel) {
TreeNode visitLibrary(Library node, TreeNode? removalSentinel) {
staticTypeContext.enterLibrary(node);
Library result = super.visitLibrary(node, removalSentinel) as Library;
staticTypeContext.leaveLibrary(node);
@ -133,7 +133,7 @@ class RecursiveContinuationRewriter extends RemovingTransformer {
}
@override
visitFunctionNode(FunctionNode node, TreeNode? removalSentinel) {
TreeNode visitFunctionNode(FunctionNode node, TreeNode? removalSentinel) {
switch (node.asyncMarker) {
case AsyncMarker.Sync:
case AsyncMarker.SyncYielding:
@ -497,7 +497,7 @@ class SyncStarFunctionRewriter extends ContinuationRewriterBase {
}
@override
visitYieldStatement(YieldStatement node, TreeNode? removalSentinel) {
TreeNode visitYieldStatement(YieldStatement node, TreeNode? removalSentinel) {
Expression transformedExpression = transform(node.expression);
var statements = <Statement>[];
@ -1194,7 +1194,7 @@ abstract class AsyncRewriterBase extends ContinuationRewriterBase {
}
@override
defaultExpression(TreeNode node, TreeNode? removalSentinel) =>
TreeNode defaultExpression(TreeNode node, TreeNode? removalSentinel) =>
throw 'unreachable $node';
}
@ -1447,7 +1447,8 @@ class AsyncFunctionRewriter extends AsyncRewriterBase {
}
@override
visitReturnStatement(ReturnStatement node, TreeNode? removalSentinel) {
TreeNode visitReturnStatement(
ReturnStatement node, TreeNode? removalSentinel) {
var expr = node.expression == null
? new NullLiteral()
: expressionRewriter!.rewrite(node.expression!, statements);

2
pkg/kernel/lib/transformations/mixin_full_resolution.dart
View file

@ -64,7 +64,7 @@ class MixinFullResolution {
hierarchy.applyMemberChanges(transformedClasses, findDescendants: true);
}
transformClass(
void transformClass(
List<Library> librariesToBeTransformed,
Set<Class> processedClasses,
Set<Class> transformedClasses,

74
pkg/kernel/lib/type_checker.dart
View file

@ -118,9 +118,9 @@ abstract class TypeChecker {
class TypeCheckingVisitor
implements
ExpressionVisitor<DartType>,
StatementVisitor<Null>,
MemberVisitor<Null>,
InitializerVisitor<Null> {
StatementVisitor<void>,
MemberVisitor<void>,
InitializerVisitor<void> {
final TypeChecker checker;
final TypeEnvironment environment;
final ClassHierarchy hierarchy;
@ -171,7 +171,7 @@ class TypeCheckingVisitor
}
@override
defaultMember(Member node) => throw 'Unused';
TreeNode defaultMember(Member node) => throw 'Unused';
@override
DartType defaultBasicLiteral(BasicLiteral node) {
@ -184,17 +184,17 @@ class TypeCheckingVisitor
}
@override
defaultStatement(Statement node) {
TreeNode defaultStatement(Statement node) {
throw 'Unexpected statement ${node.runtimeType}';
}
@override
defaultInitializer(Initializer node) {
TreeNode defaultInitializer(Initializer node) {
throw 'Unexpected initializer ${node.runtimeType}';
}
@override
visitField(Field node) {
void visitField(Field node) {
if (node.initializer != null) {
node.initializer =
checkAndDowncastExpression(node.initializer!, node.type);
@ -202,7 +202,7 @@ class TypeCheckingVisitor
}
@override
visitConstructor(Constructor node) {
void visitConstructor(Constructor node) {
currentReturnType = null;
currentYieldType = null;
node.initializers.forEach(visitInitializer);
@ -210,14 +210,14 @@ class TypeCheckingVisitor
}
@override
visitProcedure(Procedure node) {
void visitProcedure(Procedure node) {
currentReturnType = _getInternalReturnType(node.function);
currentYieldType = _getYieldType(node.function);
handleFunctionNode(node.function);
}
@override
visitRedirectingFactory(RedirectingFactory node) {
void visitRedirectingFactory(RedirectingFactory node) {
currentReturnType = null;
currentYieldType = null;
}
@ -836,12 +836,12 @@ class TypeCheckingVisitor
}
@override
visitConstantExpression(ConstantExpression node) {
DartType visitConstantExpression(ConstantExpression node) {
return node.type;
}
@override
visitAssertStatement(AssertStatement node) {
void visitAssertStatement(AssertStatement node) {
visitExpression(node.condition);
if (node.message != null) {
visitExpression(node.message!);
@ -849,38 +849,38 @@ class TypeCheckingVisitor
}
@override
visitBlock(Block node) {
void visitBlock(Block node) {
node.statements.forEach(visitStatement);
}
@override
visitAssertBlock(AssertBlock node) {
void visitAssertBlock(AssertBlock node) {
node.statements.forEach(visitStatement);
}
@override
visitBreakStatement(BreakStatement node) {}
void visitBreakStatement(BreakStatement node) {}
@override
visitContinueSwitchStatement(ContinueSwitchStatement node) {}
void visitContinueSwitchStatement(ContinueSwitchStatement node) {}
@override
visitDoStatement(DoStatement node) {
void visitDoStatement(DoStatement node) {
visitStatement(node.body);
node.condition = checkAndDowncastExpression(
node.condition, environment.coreTypes.boolLegacyRawType);
}
@override
visitEmptyStatement(EmptyStatement node) {}
void visitEmptyStatement(EmptyStatement node) {}
@override
visitExpressionStatement(ExpressionStatement node) {
void visitExpressionStatement(ExpressionStatement node) {
visitExpression(node.expression);
}
@override
visitForInStatement(ForInStatement node) {
void visitForInStatement(ForInStatement node) {
DartType iterable = visitExpression(node.iterable);
// TODO(asgerf): Store interface targets on for-in loops or desugar them,
// instead of doing the ad-hoc resolution here.
@ -935,7 +935,7 @@ class TypeCheckingVisitor
}
@override
visitForStatement(ForStatement node) {
void visitForStatement(ForStatement node) {
node.variables.forEach(visitVariableDeclaration);
if (node.condition != null) {
node.condition = checkAndDowncastExpression(
@ -946,12 +946,12 @@ class TypeCheckingVisitor
}
@override
visitFunctionDeclaration(FunctionDeclaration node) {
void visitFunctionDeclaration(FunctionDeclaration node) {
handleNestedFunctionNode(node.function);
}
@override
visitIfStatement(IfStatement node) {
void visitIfStatement(IfStatement node) {
node.condition = checkAndDowncastExpression(
node.condition, environment.coreTypes.boolLegacyRawType);
visitStatement(node.then);
@ -961,12 +961,12 @@ class TypeCheckingVisitor
}
@override
visitLabeledStatement(LabeledStatement node) {
void visitLabeledStatement(LabeledStatement node) {
visitStatement(node.body);
}
@override
visitReturnStatement(ReturnStatement node) {
void visitReturnStatement(ReturnStatement node) {
Expression? expression = node.expression;
if (expression != null) {
if (currentReturnType == null) {
@ -982,7 +982,7 @@ class TypeCheckingVisitor
}
@override
visitSwitchStatement(SwitchStatement node) {
void visitSwitchStatement(SwitchStatement node) {
visitExpression(node.expression);
for (SwitchCase switchCase in node.cases) {
switchCase.expressions.forEach(visitExpression);
@ -991,7 +991,7 @@ class TypeCheckingVisitor
}
@override
visitTryCatch(TryCatch node) {
void visitTryCatch(TryCatch node) {
visitStatement(node.body);
for (Catch catchClause in node.catches) {
visitStatement(catchClause.body);
@ -999,13 +999,13 @@ class TypeCheckingVisitor
}
@override
visitTryFinally(TryFinally node) {
void visitTryFinally(TryFinally node) {
visitStatement(node.body);
visitStatement(node.finalizer);
}
@override
visitVariableDeclaration(VariableDeclaration node) {
void visitVariableDeclaration(VariableDeclaration node) {
if (node.initializer != null) {
node.initializer =
checkAndDowncastExpression(node.initializer!, node.type);
@ -1013,14 +1013,14 @@ class TypeCheckingVisitor
}
@override
visitWhileStatement(WhileStatement node) {
void visitWhileStatement(WhileStatement node) {
node.condition = checkAndDowncastExpression(
node.condition, environment.coreTypes.boolLegacyRawType);
visitStatement(node.body);
}
@override
visitYieldStatement(YieldStatement node) {
void visitYieldStatement(YieldStatement node) {
if (node.isYieldStar) {
Class container = currentAsyncMarker == AsyncMarker.AsyncStar
? coreTypes.streamClass
@ -1042,35 +1042,35 @@ class TypeCheckingVisitor
}
@override
visitFieldInitializer(FieldInitializer node) {
void visitFieldInitializer(FieldInitializer node) {
node.value = checkAndDowncastExpression(node.value, node.field.type);
}
@override
visitRedirectingInitializer(RedirectingInitializer node) {
void visitRedirectingInitializer(RedirectingInitializer node) {
handleCall(node.arguments, node.target.getterType,
typeParameters: const <TypeParameter>[]);
}
@override
visitSuperInitializer(SuperInitializer node) {
void visitSuperInitializer(SuperInitializer node) {
handleCall(node.arguments, node.target.getterType,
typeParameters: const <TypeParameter>[],
receiver: getSuperReceiverType(node.target));
}
@override
visitLocalInitializer(LocalInitializer node) {
void visitLocalInitializer(LocalInitializer node) {
visitVariableDeclaration(node.variable);
}
@override
visitAssertInitializer(AssertInitializer node) {
void visitAssertInitializer(AssertInitializer node) {
visitAssertStatement(node.statement);
}
@override
visitInvalidInitializer(InvalidInitializer node) {}
void visitInvalidInitializer(InvalidInitializer node) {}
@override
DartType visitDynamicGet(DynamicGet node) {

84
pkg/kernel/lib/verifier.dart
View file

@ -23,7 +23,7 @@ class VerificationError {
VerificationError(this.context, this.node, this.details);
@override
toString() {
String toString() {
Location? location;
try {
location = node?.location ?? context?.location;
@ -98,23 +98,23 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
afterConst = afterConst ?? !(isOutline ?? false);
@override
defaultTreeNode(TreeNode node) {
void defaultTreeNode(TreeNode node) {
visitChildren(node);
}
@override
defaultConstantReference(Constant constant) {
void defaultConstantReference(Constant constant) {
if (seenConstants.add(constant)) {
constant.accept(this);
}
}
@override
defaultConstant(Constant constant) {
void defaultConstant(Constant constant) {
constant.visitChildren(this);
}
problem(TreeNode? node, String details, {TreeNode? context}) {
void problem(TreeNode? node, String details, {TreeNode? context}) {
context ??= currentClassOrExtensionOrMember;
throw new VerificationError(context, node, details);
}
@ -211,7 +211,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitComponent(Component component) {
void visitComponent(Component component) {
try {
for (Library library in component.libraries) {
for (Class class_ in library.classes) {
@ -249,7 +249,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitExtension(Extension node) {
void visitExtension(Extension node) {
currentExtension = node;
declareTypeParameters(node.typeParameters);
final TreeNode? oldParent = enterParent(node);
@ -281,14 +281,14 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitTypedef(Typedef node) {
void visitTypedef(Typedef node) {
checkTypedef(node);
// Enter and exit the node to check the parent pointer on the typedef node.
exitParent(enterParent(node));
}
@override
visitField(Field node) {
void visitField(Field node) {
currentMember = node;
TreeNode? oldParent = enterParent(node);
bool isTopLevel = node.parent == currentLibrary;
@ -331,7 +331,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitProcedure(Procedure node) {
void visitProcedure(Procedure node) {
currentMember = node;
TreeNode? oldParent = enterParent(node);
classTypeParametersAreInScope = !node.isStatic;
@ -382,7 +382,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitConstructor(Constructor node) {
void visitConstructor(Constructor node) {
currentMember = node;
classTypeParametersAreInScope = true;
// The constructor member needs special treatment due to parameters being
@ -403,7 +403,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitClass(Class node) {
void visitClass(Class node) {
currentClass = node;
declareTypeParameters(node.typeParameters);
TreeNode? oldParent = enterParent(node);
@ -420,7 +420,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitFunctionNode(FunctionNode node) {
void visitFunctionNode(FunctionNode node) {
declareTypeParameters(node.typeParameters);
bool savedInCatchBlock = inCatchBlock;
AsyncMarker savedAsyncMarker = currentAsyncMarker;
@ -440,7 +440,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitFunctionType(FunctionType node) {
void visitFunctionType(FunctionType node) {
for (int i = 1; i < node.namedParameters.length; ++i) {
if (node.namedParameters[i - 1].compareTo(node.namedParameters[i]) >= 0) {
problem(currentParent,
@ -462,22 +462,22 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitBlock(Block node) {
void visitBlock(Block node) {
visitWithLocalScope(node);
}
@override
visitForStatement(ForStatement node) {
void visitForStatement(ForStatement node) {
visitWithLocalScope(node);
}
@override
visitForInStatement(ForInStatement node) {
void visitForInStatement(ForInStatement node) {
visitWithLocalScope(node);
}
@override
visitLet(Let node) {
void visitLet(Let node) {
if (_isCompileTimeErrorEncoding(node)) return;
visitWithLocalScope(node);
}
@ -488,7 +488,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitBlockExpression(BlockExpression node) {
void visitBlockExpression(BlockExpression node) {
int stackHeight = enterLocalScope();
// Do not visit the block directly because the value expression needs to
// be in its scope.
@ -504,7 +504,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitCatch(Catch node) {
void visitCatch(Catch node) {
bool savedInCatchBlock = inCatchBlock;
inCatchBlock = true;
visitWithLocalScope(node);
@ -550,14 +550,14 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitRethrow(Rethrow node) {
void visitRethrow(Rethrow node) {
if (!inCatchBlock) {
problem(node, "Rethrow must be inside a Catch block.");
}
}
@override
visitVariableDeclaration(VariableDeclaration node) {
void visitVariableDeclaration(VariableDeclaration node) {
TreeNode? parent = node.parent;
if (parent is! Block &&
!(parent is Catch && parent.body != node) &&
@ -586,7 +586,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitVariableGet(VariableGet node) {
void visitVariableGet(VariableGet node) {
checkVariableInScope(node.variable, node);
visitChildren(node);
if (afterConst && node.variable.isConst) {
@ -595,13 +595,13 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitVariableSet(VariableSet node) {
void visitVariableSet(VariableSet node) {
checkVariableInScope(node.variable, node);
visitChildren(node);
}
@override
visitStaticGet(StaticGet node) {
void visitStaticGet(StaticGet node) {
visitChildren(node);
// ignore: unnecessary_null_comparison
if (node.target == null) {
@ -627,7 +627,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitStaticSet(StaticSet node) {
void visitStaticSet(StaticSet node) {
visitChildren(node);
// ignore: unnecessary_null_comparison
if (node.target == null) {
@ -642,7 +642,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitStaticInvocation(StaticInvocation node) {
void visitStaticInvocation(StaticInvocation node) {
checkTargetedInvocation(node.target, node);
if (node.target.isInstanceMember) {
problem(node,
@ -694,7 +694,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitConstructorInvocation(ConstructorInvocation node) {
void visitConstructorInvocation(ConstructorInvocation node) {
checkTargetedInvocation(node.target, node);
if (node.target.enclosingClass.isAbstract) {
problem(node, "ConstructorInvocation of abstract class.");
@ -730,7 +730,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitListLiteral(ListLiteral node) {
void visitListLiteral(ListLiteral node) {
visitChildren(node);
if (afterConst && node.isConst) {
problem(node, "Constant list literal.");
@ -738,7 +738,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitSetLiteral(SetLiteral node) {
void visitSetLiteral(SetLiteral node) {
visitChildren(node);
if (afterConst && node.isConst) {
problem(node, "Constant set literal.");
@ -746,7 +746,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitMapLiteral(MapLiteral node) {
void visitMapLiteral(MapLiteral node) {
visitChildren(node);
if (afterConst && node.isConst) {
problem(node, "Constant map literal.");
@ -754,14 +754,14 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitSymbolLiteral(SymbolLiteral node) {
void visitSymbolLiteral(SymbolLiteral node) {
if (afterConst) {
problem(node, "Symbol literal.");
}
}
@override
visitContinueSwitchStatement(ContinueSwitchStatement node) {
void visitContinueSwitchStatement(ContinueSwitchStatement node) {
// ignore: unnecessary_null_comparison
if (node.target == null) {
problem(node, "No target.");
@ -777,7 +777,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitInstanceConstant(InstanceConstant constant) {
void visitInstanceConstant(InstanceConstant constant) {
constant.visitChildren(this);
if (constant.typeArguments.length !=
constant.classNode.typeParameters.length) {
@ -814,7 +814,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitUnevaluatedConstant(UnevaluatedConstant constant) {
void visitUnevaluatedConstant(UnevaluatedConstant constant) {
if (inUnevaluatedConstant) {
problem(currentParent, "UnevaluatedConstant in UnevaluatedConstant.");
}
@ -828,7 +828,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
defaultMemberReference(Member node) {
void defaultMemberReference(Member node) {
if (node.transformerFlags & TransformerFlag.seenByVerifier == 0) {
problem(
node, "Dangling reference to '$node', parent is: '${node.parent}'.");
@ -836,7 +836,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitClassReference(Class node) {
void visitClassReference(Class node) {
if (!classes.contains(node)) {
problem(
node, "Dangling reference to '$node', parent is: '${node.parent}'.");
@ -844,7 +844,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitTypedefReference(Typedef node) {
void visitTypedefReference(Typedef node) {
if (!typedefs.contains(node)) {
problem(
node, "Dangling reference to '$node', parent is: '${node.parent}'");
@ -852,7 +852,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitTypeParameterType(TypeParameterType node) {
void visitTypeParameterType(TypeParameterType node) {
TypeParameter parameter = node.parameter;
if (!typeParametersInScope.contains(parameter)) {
TreeNode? owner = parameter.parent is FunctionNode
@ -872,7 +872,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitInterfaceType(InterfaceType node) {
void visitInterfaceType(InterfaceType node) {
node.visitChildren(this);
if (node.typeArguments.length != node.classNode.typeParameters.length) {
problem(
@ -902,7 +902,7 @@ class VerifyingVisitor extends RecursiveResultVisitor<void> {
}
@override
visitTypedefType(TypedefType node) {
void visitTypedefType(TypedefType node) {
checkTypedef(node.typedefNode);
node.visitChildren(this);
if (node.typeArguments.length != node.typedefNode.typeParameters.length) {
@ -1020,7 +1020,7 @@ class CheckParentPointers extends Visitor<void> with VisitorVoidMixin {
CheckParentPointers([this.parent]);
@override
defaultTreeNode(TreeNode node) {
void defaultTreeNode(TreeNode node) {
if (node.parent != parent) {
throw new VerificationError(
parent,

2
pkg/kernel/test/ast_membench.dart
View file

@ -8,7 +8,7 @@ import 'dart:io';
/// Builds N copies of the AST for the given component.
/// Pass --print-metrics to the Dart VM to measure the memory use.
main(List<String> args) {
void main(List<String> args) {
if (args.length == 0) {
print('USAGE: ast_membench FILE.dill NUM_COPIES');
exit(1);

2
pkg/kernel/test/binary/can_read_platform_test.dart
View file

@ -7,7 +7,7 @@ import 'dart:io';
import 'package:kernel/binary/ast_from_binary.dart';
import 'package:kernel/kernel.dart';
main() {
void main() {
File exe = new File(Platform.resolvedExecutable).absolute;
int steps = 0;
Directory parent = exe.parent.parent;

6
pkg/kernel/test/binary/component_mode_test.dart
View file

@ -6,12 +6,12 @@ import 'package:kernel/binary/ast_from_binary.dart';
import 'utils.dart';
main() {
setCompileMode(Component c, NonNullableByDefaultCompiledMode mode) {
void main() {
void setCompileMode(Component c, NonNullableByDefaultCompiledMode mode) {
c.setMainMethodAndMode(null, true, mode);
}
verifyMode(Component c, NonNullableByDefaultCompiledMode mode) {
void verifyMode(Component c, NonNullableByDefaultCompiledMode mode) {
if (c.mode != mode) {
throw "Serialized and re-read component had change in mode: "
"Expected $mode got ${c.mode}.";

2
pkg/kernel/test/binary/invalid_index_size.dart
View file

@ -6,7 +6,7 @@ import 'package:kernel/binary/ast_from_binary.dart' show ParseError;
import 'utils.dart';
main() {
void main() {
Uri uri = Uri.parse("foo://bar.dart");
Library lib1 = new Library(uri, fileUri: uri);
Component c1 = new Component(libraries: [lib1]);

2
pkg/kernel/test/binary/lazy_reading_test.dart
View file

@ -6,7 +6,7 @@ import 'package:kernel/binary/ast_from_binary.dart';
import 'package:kernel/src/tool/find_referenced_libraries.dart';
import 'utils.dart';
main() {
void main() {
Library lib;
{
/// Create a library with two classes (A and B) where class A - in its

14
pkg/kernel/test/binary/library_flags_test.dart
View file

@ -5,34 +5,34 @@
import 'utils.dart';
/// Test that library flags are serialized and read correctly.
main() {
setSynthetic(Library lib, bool isSynthetic) {
void main() {
void setSynthetic(Library lib, bool isSynthetic) {
lib.isSynthetic = isSynthetic;
}
verifySynthetic(Library lib, bool isSynthetic) {
void verifySynthetic(Library lib, bool isSynthetic) {
if (lib.isSynthetic != isSynthetic) {
throw "Serialized and re-read library had change in synthetic flag.";
}
}
setNonNullableByDefault(Library lib, bool isNonNullableByDefault) {
void setNonNullableByDefault(Library lib, bool isNonNullableByDefault) {
lib.isNonNullableByDefault = isNonNullableByDefault;
}
verifyNonNullableByDefault(Library lib, bool isNonNullableByDefault) {
void verifyNonNullableByDefault(Library lib, bool isNonNullableByDefault) {
if (lib.isNonNullableByDefault != isNonNullableByDefault) {
throw "Serialized and re-read library had change in "
"isNonNullableByDefault flag.";
}
}
setNonNullableByDefaultCompiledMode(Library lib,
void setNonNullableByDefaultCompiledMode(Library lib,
NonNullableByDefaultCompiledMode nonNullableByDefaultCompiledMode) {
lib.nonNullableByDefaultCompiledMode = nonNullableByDefaultCompiledMode;
}
verifyNonNullableByDefaultCompiledMode(Library lib,
void verifyNonNullableByDefaultCompiledMode(Library lib,
NonNullableByDefaultCompiledMode nonNullableByDefaultCompiledMode) {
if (lib.nonNullableByDefaultCompiledMode !=
nonNullableByDefaultCompiledMode) {

4
pkg/kernel/test/binary_bench.dart
View file

@ -38,7 +38,7 @@ late File sourceDill;
bool forGolem = false;
bool forRaw = false;
main(List<String> args) async {
void main(List<String> args) async {
if (!_parseArgs(args)) {
print(usage);
exit(-1);
@ -111,7 +111,7 @@ class BenchmarkResult {
void report() {
runsUs.sort();
P(int p) => runsUs[((runsUs.length - 1) * (p / 100)).ceil()];
int P(int p) => runsUs[((runsUs.length - 1) * (p / 100)).ceil()];
final sum = runsUs.reduce(add);
final avg = sum / runsUs.length;

2
pkg/kernel/test/class_hierarchy_basic.dart
View file

@ -265,5 +265,5 @@ class BasicClassHierarchy implements ClassHierarchy {
int getSuperTypeHashTableSize() => 0;
@override
noSuchMethod(inv) => super.noSuchMethod(inv);
dynamic noSuchMethod(inv) => super.noSuchMethod(inv);
}

2
pkg/kernel/test/class_hierarchy_bench.dart
View file

@ -26,7 +26,7 @@ Options:
${argParser.usage}
''';
main(List<String> args) {
void main(List<String> args) {
if (args.length == 0) {
print(usage);
exit(1);

2
pkg/kernel/test/class_hierarchy_membench.dart
View file

@ -26,7 +26,7 @@ ${argParser.usage}
/// Builds N copies of the class hierarchy for the given component.
/// Pass --print-metrics to the Dart VM to measure the memory use.
main(List<String> args) {
void main(List<String> args) {
if (args.length == 0) {
print(usage);
exit(1);

2
pkg/kernel/test/class_hierarchy_self_check.dart
View file

@ -11,7 +11,7 @@ import 'dart:io';
import 'dart:math';
import 'self_check_util.dart';
main(List<String> args) {
void main(List<String> args) {
runSelfCheck(args, (String filename) {
testClassHierarchyOnComponent(loadComponentFromBinary(filename));
});

2
pkg/kernel/test/class_hierarchy_test.dart
View file

@ -11,7 +11,7 @@ import "package:kernel/testing/mock_sdk_component.dart";
import "package:kernel/text/ast_to_text.dart";
import "package:kernel/src/text_util.dart";
main() {
void main() {
new ClosedWorldClassHierarchyTest().test_applyTreeChanges();
new ClosedWorldClassHierarchyTest().test_applyMemberChanges();

2
pkg/kernel/test/class_hierarchy_test_disabled.dart
View file

@ -6,7 +6,7 @@ import 'package:kernel/kernel.dart';
import 'package:test/test.dart';
import 'class_hierarchy_self_check.dart';
main() {
void main() {
test('All-pairs class hierarchy tests on dart2js', () {
testClassHierarchyOnComponent(
loadComponentFromBinary('test/data/dart2js.dill'));

2
pkg/kernel/test/clone_test.dart
View file

@ -9,7 +9,7 @@ import 'package:kernel/src/coverage.dart';
import 'package:kernel/src/equivalence.dart';
import 'package:kernel/src/node_creator.dart';
main() {
void main() {
testBodyCloning();
testBodyCloningInContext();
testMemberCloning();

6
pkg/kernel/test/constant_equals_test.dart
View file

@ -4,7 +4,7 @@
import 'package:kernel/ast.dart';
testEquals(Constant a, Constant b) {
void testEquals(Constant a, Constant b) {
if (a != b) {
throw 'Expected $a and $b to be equal.';
}
@ -13,13 +13,13 @@ testEquals(Constant a, Constant b) {
}
}
testNotEquals(Constant a, Constant b) {
void testNotEquals(Constant a, Constant b) {
if (a == b) {
throw 'Expected $a and $b to be not equal.';
}
}
main() {
void main() {
Uri uri = Uri.parse('test:uri');
Procedure procedure1 = new Procedure(
new Name('foo'), ProcedureKind.Method, new FunctionNode(null),

2
pkg/kernel/test/convert_field_to_setter_getter.dart
View file

@ -6,7 +6,7 @@ import 'package:kernel/binary/ast_from_binary.dart';
import 'package:kernel/binary/ast_to_binary.dart';
import 'binary/utils.dart';
main() {
void main() {
final Uri lib1Uri = Uri.parse('org-dartlang:///lib.dart');
final Library lib1 = new Library(lib1Uri, fileUri: lib1Uri);
final Field field = new Field.mutable(new Name("f"), fileUri: lib1Uri);

8
pkg/kernel/test/dart_type_equivalence_test.dart
View file

@ -8,7 +8,7 @@ import 'package:kernel/ast.dart';
import 'package:kernel/src/dart_type_equivalence.dart';
import 'package:kernel/testing/type_parser_environment.dart';
run() {
void run() {
// Simple types.
areEqual("int", "int");
notEqual("int", "String");
@ -164,7 +164,7 @@ run() {
equateTopTypes: true, ignoreTopLevelNullability: true);
}
areEqual(String type1, String type2,
void areEqual(String type1, String type2,
{String typeParameters = '',
bool equateTopTypes = false,
bool ignoreAllNullabilities = false,
@ -204,7 +204,7 @@ areEqual(String type1, String type2,
"with flags ${flagNamesForDebug.map((f) => "'$f'").join(", ")}.");
}
notEqual(String type1, String type2,
void notEqual(String type1, String type2,
{String typeParameters = '',
bool equateTopTypes = false,
bool ignoreAllNullabilities = false,
@ -244,4 +244,4 @@ notEqual(String type1, String type2,
"with flags ${flagNamesForDebug.map((f) => "'$f'").join(", ")}.");
}
main() => run();
void main() => run();

2
pkg/kernel/test/equivalence_test.dart
View file

@ -125,7 +125,7 @@ Inequivalent references:
'''),
];
main() {
void main() {
for (Test test in tests) {
EquivalenceResult result =
checkEquivalence(test.a, test.b, strategy: test.strategy);

2
pkg/kernel/test/equivalent_dill_test.dart
View file

@ -10,7 +10,7 @@ import 'package:kernel/binary/ast_from_binary.dart';
import 'package:kernel/kernel.dart';
import 'package:kernel/src/equivalence.dart';
main(List<String> args) {
void main(List<String> args) {
String resolvedExecutable = Platform.environment['resolvedExecutable'];
File exe =
new File(resolvedExecutable ?? Platform.resolvedExecutable).absolute;

2
pkg/kernel/test/flatten_test.dart
View file

@ -65,7 +65,7 @@ class Test {
const Test(this.input, this.output, [this.typeParameters]);
}
main() {
void main() {
Env env = new Env('', isNonNullableByDefault: true);
ClassHierarchy classHierarchy =
new ClassHierarchy(env.component, env.coreTypes);

2
pkg/kernel/test/future_value_type_test.dart
View file

@ -67,7 +67,7 @@ const Map<String, String> data = {
'FutureOr<void>*': 'void',
};
main() {
void main() {
Env env = new Env('', isNonNullableByDefault: true)
..extendWithTypeParameters('X,'
'X_extends_FutureInt extends Future<int>,'

2
pkg/kernel/test/graph_test.dart
View file

@ -35,7 +35,7 @@ void checkGraph(Map<String, List<String>> graph, String startingNodeName,
Expect.stringEquals(expectedReversed.join(", "), result.join(", "));
}
main() {
void main() {
test("[[B, A], [C], [D]]", {
"A": ["B"],
"B": ["A"],

4
pkg/kernel/test/heap_test.dart
View file

@ -5,8 +5,8 @@
import 'package:kernel/src/heap.dart';
import 'package:test/test.dart';
main() {
check_sort(Iterable<int> initialOrder) {
void main() {
void check_sort(Iterable<int> initialOrder) {
var values = initialOrder.toList();
var heap = new _intHeap();
values.forEach(heap.add);

2
pkg/kernel/test/import_table_test.dart
View file

@ -4,7 +4,7 @@
import 'package:kernel/import_table.dart';
main() {
void main() {
List<String> paths = <String>[];
paths.add("file://");
paths.add("file:///a");

2
pkg/kernel/test/indentation_test.dart
View file

@ -5,7 +5,7 @@
import 'package:expect/expect.dart';
import 'package:kernel/text/indentation.dart' show Indentation;
main() {
void main() {
Indentation ind = new Indentation();
Expect.stringEquals("", ind.indentation);

2
pkg/kernel/test/legacy_erasure_test.dart
View file

@ -53,7 +53,7 @@ const Map<String, String> data = {
'<T extends List<T>>(T) -> void': '<T extends List<T*>*>(T) ->* void',
};
main() {
void main() {
Env env = new Env('', isNonNullableByDefault: true);
data.forEach((String input, String output) {
DartType inputType = env.parseType(input);

2
pkg/kernel/test/load_concat_dill_keeps_source_test.dart
View file

@ -13,7 +13,7 @@ import 'package:kernel/kernel.dart';
Uri uri1 = Uri.parse("foo://lib1.dart");
Uri uri2 = Uri.parse("foo://lib2.dart");
main() {
void main() {
Library library1 = new Library(uri1, fileUri: uri1);
Library library2 = new Library(uri2, fileUri: uri2);
Procedure p1 = new Procedure(new Name("p1"), ProcedureKind.Method,

4
pkg/kernel/test/metadata_test.dart
View file

@ -106,7 +106,7 @@ class Visitor extends RecursiveVisitor {
Visitor(this.predicate, this.handle);
@override
defaultTreeNode(TreeNode node) {
void defaultTreeNode(TreeNode node) {
super.defaultTreeNode(node);
if (MetadataRepository.isSupported(node) && predicate(node)) {
handle(node);
@ -154,7 +154,7 @@ List<int> toBinary(Component p) {
return sink.builder.takeBytes();
}
main() async {
void main() async {
bool anyNode(TreeNode node) => true;
bool onlyMethods(TreeNode node) =>
node is Procedure &&

2
pkg/kernel/test/nnbd_top_merge_test.dart
View file

@ -121,7 +121,7 @@ const Map<String, dynamic> data = {
'<T>(T) -> void vs <T>(invalid) -> void': '<T>(invalid) -> void',
};
main() {
void main() {
Env env = new Env('', isNonNullableByDefault: true);
data.forEach((String input, dynamic output) {
List<String> parts = input.split(' vs ');

2
pkg/kernel/test/non_null_test.dart
View file

@ -77,7 +77,7 @@ const Map<String, String> data = {
'Y_extends_dynamic & X_extends_dynamic',
};
main() {
void main() {
Env env = new Env('', isNonNullableByDefault: true)
..extendWithTypeParameters('X,'
'X_extends_Object extends Object,'

8
pkg/kernel/test/norm_test.dart
View file

@ -8,7 +8,7 @@ import 'package:kernel/ast.dart';
import 'package:kernel/src/norm.dart';
import 'package:kernel/testing/type_parser_environment.dart';
run() {
void run() {
checkNormToSame('Null');
checkNormToSame('Never');
check('Never?', 'Null');
@ -142,7 +142,7 @@ run() {
'FutureOr<FutureOr<FutureOr<int>>?>?');
}
check(String input, String output, [String typeParameters = '']) {
void check(String input, String output, [String typeParameters = '']) {
Env env = new Env('', isNonNullableByDefault: true)
..extendWithTypeParameters(typeParameters);
DartType inputType = env.parseType(input);
@ -157,8 +157,8 @@ check(String input, String output, [String typeParameters = '']) {
"Actual: ${actualOutputType}");
}
checkNormToSame(String type, [String typeParameters = '']) {
void checkNormToSame(String type, [String typeParameters = '']) {
return check(type, type, typeParameters);
}
main() => run();
void main() => run();

2
pkg/kernel/test/relink_test.dart
View file

@ -7,7 +7,7 @@ import 'package:kernel/binary/ast_to_binary.dart';
import 'package:kernel/src/tool/find_referenced_libraries.dart';
import 'binary/utils.dart';
main() {
void main() {
Component component1 = createComponent(42);
Component component2 = createComponent(43);

2
pkg/kernel/test/self_check_util.dart
View file

@ -15,7 +15,7 @@ import 'package:kernel/src/tool/batch_util.dart';
///
/// The test can either be run with a single file passed on the command line
/// or run in batch mode.
runSelfCheck(List<String> args, void runTest(String filename)) {
void runSelfCheck(List<String> args, void runTest(String filename)) {
Future<CompilerOutcome> batchMain(List<String> arguments) async {
if (arguments.length != 1) {
throw 'Exactly one argument expected';

2
pkg/kernel/test/serialize_bench.dart
View file

@ -12,7 +12,7 @@ Deserialize INPUT and write it back to OUTPUT several times, measuring
the time it takes, including I/O time.
''';
main(List<String> args) async {
void main(List<String> args) async {
if (args.length != 2) {
print(usage);
exit(1);

2
pkg/kernel/test/type_hashcode_quality.dart
View file

@ -31,7 +31,7 @@ class DartTypeCollector extends RecursiveVisitor {
int numberOfTypes = 0;
@override
defaultDartType(DartType node) {
void defaultDartType(DartType node) {
if (!seenTypes.add(node)) return;
++numberOfTypes;
int hash = node.hashCode;

4
pkg/kernel/test/type_parser_test.dart
View file

@ -6,11 +6,11 @@ import 'package:expect/expect.dart' show Expect;
import 'package:kernel/testing/type_parser.dart';
testParse(String text) {
void testParse(String text) {
Expect.stringEquals(text.trim(), "${parse(text).join('\n')}");
}
main() {
void main() {
testParse("""
() ->* void
() ->? void

2
pkg/kernel/test/type_substitute_bounds_test.dart
View file

@ -63,7 +63,7 @@ TestCase testCase(String type, Map<String, TypeBound> bounds, String expected) {
return new TestCase(type, bounds, expected);
}
main() {
void main() {
for (var testCase in testCases) {
test('$testCase', () {
var environment = new LazyTypeEnvironment();

4
pkg/kernel/test/type_substitution_identity_test.dart
View file

@ -8,7 +8,7 @@ import 'type_parser.dart';
import 'type_hashcode_test.dart' show testCases;
import 'package:test/test.dart';
checkType(DartType type) {
void checkType(DartType type) {
var map = {new TypeParameter(): const DynamicType()};
var other = substitute(type, map);
if (!identical(type, other)) {
@ -20,7 +20,7 @@ checkType(DartType type) {
}
}
main() {
void main() {
for (var testCase in testCases) {
test('$testCase', () {
var env = new LazyTypeEnvironment();

2
pkg/kernel/test/typedef_unalias_test.dart
View file

@ -14,7 +14,7 @@ void harnessTest(String name, void doTest(TestHarness harness)) {
});
}
main() {
void main() {
harnessTest('`Foo` where typedef Foo = C', (TestHarness harness) {
var foo = new Typedef('Foo', harness.otherLegacyRawType, fileUri: dummyUri);
harness.enclosingLibrary.addTypedef(foo);

12
pkg/kernel/test/union_find_test.dart
View file

@ -4,11 +4,11 @@
import 'package:kernel/src/union_find.dart';
testSame<T>(UnionFind<T> unionFind, T a, T b, bool expected) {
void testSame<T>(UnionFind<T> unionFind, T a, T b, bool expected) {
expect(expected, unionFind.nodesInSameSet(unionFind[a], unionFind[b]));
}
testSets<T>(UnionFind<T> unionFind, Set<Set<T>> sets) {
void testSets<T>(UnionFind<T> unionFind, Set<Set<T>> sets) {
for (Set<T> set in sets) {
UnionFindNode<T> root = unionFind.findNode(unionFind[set.first]);
for (T value in unionFind.values) {
@ -17,15 +17,15 @@ testSets<T>(UnionFind<T> unionFind, Set<Set<T>> sets) {
}
}
testFind<T>(UnionFind<T> unionFind, T value, T expected) {
void testFind<T>(UnionFind<T> unionFind, T value, T expected) {
expect(expected, unionFind.findNode(unionFind[value]).value);
}
testUnion<T>(UnionFind<T> unionFind, T a, T b, T expected) {
void testUnion<T>(UnionFind<T> unionFind, T a, T b, T expected) {
expect(expected, unionFind.unionOfNodes(unionFind[a], unionFind[b]).value);
}
main() {
void main() {
UnionFind<int> unionFind = new UnionFind();
// {0}
testFind(unionFind, 0, 0);
@ -103,6 +103,6 @@ main() {
});
}
expect(expected, actual) {
void expect(expected, actual) {
if (expected != actual) throw 'Expected $expected, actual $actual';
}

2
pkg/kernel/test/verify_bench.dart
View file

@ -13,7 +13,7 @@ Usage: verify_bench FILE.dill
Measures the time it takes to run kernel verifier on the given component.
''';
main(List<String> args) {
void main(List<String> args) {
if (args.length != 1) {
print(usage);
exit(1);

2
pkg/kernel/test/verify_self_check.dart
View file

@ -7,7 +7,7 @@ import 'package:kernel/verifier.dart';
import 'self_check_util.dart';
main(List<String> args) {
void main(List<String> args) {
runSelfCheck(args, (String filename) {
verifyComponent(loadComponentFromBinary(filename));
});

14
pkg/kernel/test/verify_test.dart
View file

@ -14,7 +14,7 @@ import 'package:test/test.dart';
///
/// We mostly test negative cases here, as we get plenty of positive cases by
/// compiling the Dart test suite with the verifier enabled.
main() {
void main() {
positiveTest(
'Test harness has no errors',
(TestHarness test) {
@ -672,7 +672,7 @@ main() {
);
}
checkHasError(Component component, Matcher matcher) {
void checkHasError(Component component, Matcher matcher) {
try {
verifyComponent(component);
} on VerificationError catch (e) {
@ -802,7 +802,7 @@ class TestHarness {
}
}
negative1Test(String name, Node? Function(TestHarness test) nodeProvider,
void negative1Test(String name, Node? Function(TestHarness test) nodeProvider,
dynamic Function(Node? node) matcher) {
TestHarness testHarness = new TestHarness();
Node? node = nodeProvider(testHarness);
@ -818,7 +818,9 @@ negative1Test(String name, Node? Function(TestHarness test) nodeProvider,
);
}
negative2Test(String name, List<Node?> Function(TestHarness test) nodeProvider,
void negative2Test(
String name,
List<Node?> Function(TestHarness test) nodeProvider,
dynamic Function(Node? node, Node? other) matcher) {
TestHarness testHarness = new TestHarness();
List<Node?> nodes = nodeProvider(testHarness);
@ -835,7 +837,7 @@ negative2Test(String name, List<Node?> Function(TestHarness test) nodeProvider,
);
}
simpleNegativeTest(String name, dynamic matcher,
void simpleNegativeTest(String name, dynamic matcher,
void Function(TestHarness test) makeTestCase) {
TestHarness testHarness = new TestHarness();
test(
@ -850,7 +852,7 @@ simpleNegativeTest(String name, dynamic matcher,
);
}
positiveTest(String name, void makeTestCase(TestHarness test)) {
void positiveTest(String name, void makeTestCase(TestHarness test)) {
test(
name,
() {

2
pkg/kernel/tool/smoke_test_quick.dart
View file

@ -8,7 +8,7 @@ final String repoDir = _computeRepoDir();
String get dartVm => Platform.executable;
main(List<String> args) async {
void main(List<String> args) async {
Stopwatch stopwatch = new Stopwatch()..start();
List<Future> futures = <Future>[];
futures.add(run("pkg/front_end/test/spelling_test_src_suite.dart",