languages/dart-sdk
languages/dart-sdk
1
0
Fork 0
mirror of https://github.com/dart-lang/sdk synced 2024-07-20 18:05:01 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

[Kernel] Remove the syncAsync flag

Browse source 
This flag was always true so we can remove it and specialize the
remaining code that used it.  The only code that used it was in the
Dart VM's async transformation.

Specializing that code led to some unused fields in the async helper
class which were removed.  This triggered me to look at core types
which seems to have a lot of unused stuff.

Change-Id: I7da800ca17ac05478149f4c90337a38d2c2b1459
Reviewed-on: https://dart-review.googlesource.com/c/87960
Reviewed-by: Peter von der Ahé <ahe@google.com>
Commit-Queue: Kevin Millikin <kmillikin@google.com>
This commit is contained in:
Kevin Millikin 2018-12-21 10:07:04 +00:00 committed by commit-bot@chromium.org
parent 26faa44d41
commit d0c2cdcd4c
7 changed files with 44 additions and 157 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -82,7 +82,7 @@ Future<CompilerOutcome> runTransformation(List<String> arguments) async {
final hierarchy = new ClassHierarchy(component);
switch (options['transformation']) {
case 'continuation':
component = cont.transformComponent(coreTypes, component, true);
component = cont.transformComponent(coreTypes, component);
break;
case 'resolve-mixins':
mix.transformLibraries(

58
pkg/kernel/lib/core_types.dart
View file

@ -55,19 +55,13 @@ class CoreTypes {
Class _typeClass;
Class _functionClass;
Class _invocationClass;
Constructor _externalNameDefaultConstructor;
Class _invocationMirrorClass;
Constructor _invocationMirrorWithTypeConstructor;
Constructor _invocationMirrorWithoutTypeConstructor;
Class _noSuchMethodErrorClass;
Constructor _noSuchMethodErrorDefaultConstructor;
Procedure _listFromConstructor;
Procedure _listUnmodifiableConstructor;
Procedure _printProcedure;
Procedure _identicalProcedure;
Constructor _duplicatedFieldInitializerErrorDefaultConstructor;
Constructor _fallThroughErrorUrlAndLineConstructor;
Constructor _compileTimeErrorDefaultConstructor;
Procedure _objectEquals;
Procedure _mapUnmodifiable;
@ -77,15 +71,11 @@ class CoreTypes {
Class _futureClass;
Class _stackTraceClass;
Class _streamClass;
Class _completerClass;
Class _asyncAwaitCompleterClass;
Class _futureOrClass;
Constructor _asyncAwaitCompleterConstructor;
Procedure _completeOnAsyncReturnProcedure;
Procedure _completerSyncConstructor;
Procedure _completerComplete;
Procedure _completerCompleteError;
Procedure _futureMicrotaskConstructor;
Constructor _syncIterableDefaultConstructor;
Constructor _streamIteratorDefaultConstructor;
Constructor _asyncStarStreamControllerDefaultConstructor;
@ -177,20 +167,11 @@ class CoreTypes {
return _boolClass ??= index.getClass('dart:core', 'bool');
}
Class get completerClass {
return _completerClass ??= index.getClass('dart:async', 'Completer');
}
Class get asyncAwaitCompleterClass {
return _asyncAwaitCompleterClass ??=
index.getClass('dart:async', '_AsyncAwaitCompleter');
}
Procedure get completerSyncConstructor {
return _completerSyncConstructor ??=
index.getMember('dart:async', 'Completer', 'sync');
}
Constructor get asyncAwaitCompleterConstructor {
return _asyncAwaitCompleterConstructor ??=
index.getMember('dart:async', '_AsyncAwaitCompleter', '');
@ -201,11 +182,6 @@ class CoreTypes {
index.getTopLevelMember('dart:async', '_completeOnAsyncReturn');
}
Procedure get completerComplete {
return _completerComplete ??=
index.getMember('dart:async', 'Completer', 'complete');
}
Procedure get completerCompleteError {
return _completerCompleteError ??=
index.getMember('dart:async', 'Completer', 'completeError');
@ -223,11 +199,6 @@ class CoreTypes {
return _doubleClass ??= index.getClass('dart:core', 'double');
}
Constructor get externalNameDefaultConstructor {
return _externalNameDefaultConstructor ??=
index.getMember('dart:_internal', 'ExternalName', '');
}
Class get functionClass {
return _functionClass ??= index.getClass('dart:core', 'Function');
}
@ -236,11 +207,6 @@ class CoreTypes {
return _futureClass ??= index.getClass('dart:async', 'Future');
}
Procedure get futureMicrotaskConstructor {
return _futureMicrotaskConstructor ??=
index.getMember('dart:async', 'Future', 'microtask');
}
Class get futureOrClass {
return _futureOrClass ??= index.getClass('dart:async', 'FutureOr');
}
@ -272,11 +238,6 @@ class CoreTypes {
index.getMember('dart:core', '_InvocationMirror', '_withType');
}
Constructor get invocationMirrorWithoutTypeConstructor {
return _invocationMirrorWithoutTypeConstructor ??=
index.getMember('dart:core', '_InvocationMirror', '_withoutType');
}
Class get iterableClass {
return _iterableClass ??= index.getClass('dart:core', 'Iterable');
}
@ -316,11 +277,6 @@ class CoreTypes {
return _mirrorsLibrary ??= index.tryGetLibrary('dart:mirrors');
}
Class get noSuchMethodErrorClass {
return _noSuchMethodErrorClass ??=
index.getClass('dart:core', 'NoSuchMethodError');
}
Constructor get noSuchMethodErrorDefaultConstructor {
return _noSuchMethodErrorDefaultConstructor ??=
// TODO(regis): Replace 'withInvocation' with '' after dart2js is fixed.
@ -355,10 +311,6 @@ class CoreTypes {
return _pragmaOptions ??= index.getMember('dart:core', 'pragma', 'options');
}
Procedure get printProcedure {
return _printProcedure ??= index.getTopLevelMember('dart:core', 'print');
}
Class get stackTraceClass {
return _stackTraceClass ??= index.getClass('dart:core', 'StackTrace');
}
@ -421,21 +373,11 @@ class CoreTypes {
return _typeClass ??= index.getClass('dart:core', 'Type');
}
Constructor get duplicatedFieldInitializerErrorDefaultConstructor {
return _duplicatedFieldInitializerErrorDefaultConstructor ??=
index.getMember('dart:core', '_DuplicatedFieldInitializerError', '');
}
Constructor get fallThroughErrorUrlAndLineConstructor {
return _fallThroughErrorUrlAndLineConstructor ??=
index.getMember('dart:core', 'FallThroughError', '_create');
}
Constructor get compileTimeErrorDefaultConstructor {
return _compileTimeErrorDefaultConstructor ??=
index.getMember('dart:core', '_CompileTimeError', '');
}
Procedure get boolFromEnvironment {
return _boolFromEnvironment ??=
index.getMember('dart:core', 'bool', 'fromEnvironment');

3
pkg/kernel/lib/target/targets.dart
View file

@ -14,15 +14,12 @@ class TargetFlags {
final bool legacyMode;
final bool treeShake;
/// Whether `async` functions start synchronously.
final bool syncAsync;
final List<ProgramRoot> programRoots;
final Uri kernelRuntime;
TargetFlags(
{this.legacyMode: false,
this.treeShake: false,
this.syncAsync: true,
this.programRoots: const <ProgramRoot>[],
this.kernelRuntime});
}

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

@ -499,8 +499,8 @@ class ExpressionLifter extends Transformer {
}
visitFunctionNode(FunctionNode node) {
var nestedRewriter = new RecursiveContinuationRewriter(
continuationRewriter.helper, continuationRewriter.syncAsync);
var nestedRewriter =
new RecursiveContinuationRewriter(continuationRewriter.helper);
return node.accept(nestedRewriter);
}
}

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

@ -23,42 +23,36 @@ class ContinuationVariables {
static String stackTraceVar(int depth) => ':stack_trace$depth';
}
void transformLibraries(
CoreTypes coreTypes, List<Library> libraries, bool syncAsync) {
void transformLibraries(CoreTypes coreTypes, List<Library> libraries) {
var helper = new HelperNodes.fromCoreTypes(coreTypes);
var rewriter = new RecursiveContinuationRewriter(helper, syncAsync);
var rewriter = new RecursiveContinuationRewriter(helper);
for (var library in libraries) {
rewriter.rewriteLibrary(library);
}
}
Component transformComponent(
CoreTypes coreTypes, Component component, bool syncAsync) {
Component transformComponent(CoreTypes coreTypes, Component component) {
var helper = new HelperNodes.fromCoreTypes(coreTypes);
var rewriter = new RecursiveContinuationRewriter(helper, syncAsync);
var rewriter = new RecursiveContinuationRewriter(helper);
return rewriter.rewriteComponent(component);
}
Procedure transformProcedure(
CoreTypes coreTypes, Procedure procedure, bool syncAsync) {
Procedure transformProcedure(CoreTypes coreTypes, Procedure procedure) {
var helper = new HelperNodes.fromCoreTypes(coreTypes);
var rewriter = new RecursiveContinuationRewriter(helper, syncAsync);
var rewriter = new RecursiveContinuationRewriter(helper);
return rewriter.visitProcedure(procedure);
}
class RecursiveContinuationRewriter extends Transformer {
final HelperNodes helper;
/// Whether `async` functions should start synchronously.
final bool syncAsync;
final VariableDeclaration asyncJumpVariable = new VariableDeclaration(
ContinuationVariables.awaitJumpVar,
initializer: new IntLiteral(0));
final VariableDeclaration asyncContextVariable =
new VariableDeclaration(ContinuationVariables.awaitContextVar);
RecursiveContinuationRewriter(this.helper, this.syncAsync);
RecursiveContinuationRewriter(this.helper);
Component rewriteComponent(Component node) {
return node.accept(this);
@ -76,15 +70,14 @@ class RecursiveContinuationRewriter extends Transformer {
switch (node.asyncMarker) {
case AsyncMarker.Sync:
case AsyncMarker.SyncYielding:
node.transformChildren(
new RecursiveContinuationRewriter(helper, syncAsync));
node.transformChildren(new RecursiveContinuationRewriter(helper));
return node;
case AsyncMarker.SyncStar:
return new SyncStarFunctionRewriter(helper, node, syncAsync).rewrite();
return new SyncStarFunctionRewriter(helper, node).rewrite();
case AsyncMarker.Async:
return new AsyncFunctionRewriter(helper, node, syncAsync).rewrite();
return new AsyncFunctionRewriter(helper, node).rewrite();
case AsyncMarker.AsyncStar:
return new AsyncStarFunctionRewriter(helper, node, syncAsync).rewrite();
return new AsyncStarFunctionRewriter(helper, node).rewrite();
default:
return null;
}
@ -99,9 +92,8 @@ abstract class ContinuationRewriterBase extends RecursiveContinuationRewriter {
int capturedTryDepth = 0; // Deepest yield point within a try-block.
int capturedCatchDepth = 0; // Deepest yield point within a catch-block.
ContinuationRewriterBase(
HelperNodes helper, this.enclosingFunction, bool syncAsync)
: super(helper, syncAsync);
ContinuationRewriterBase(HelperNodes helper, this.enclosingFunction)
: super(helper);
/// Given a container [type], which is an instantiation of the given
/// [containerClass] extract its element type.
@ -187,14 +179,13 @@ abstract class ContinuationRewriterBase extends RecursiveContinuationRewriter {
class SyncStarFunctionRewriter extends ContinuationRewriterBase {
final VariableDeclaration iteratorVariable;
SyncStarFunctionRewriter(
HelperNodes helper, FunctionNode enclosingFunction, syncAsync)
SyncStarFunctionRewriter(HelperNodes helper, FunctionNode enclosingFunction)
: iteratorVariable = new VariableDeclaration(':iterator')
..type = new InterfaceType(helper.syncIteratorClass, [
ContinuationRewriterBase.elementTypeFrom(
helper.iterableClass, enclosingFunction.returnType)
]),
super(helper, enclosingFunction, syncAsync);
super(helper, enclosingFunction);
FunctionNode rewrite() {
// :sync_op(:iterator) {
@ -289,9 +280,8 @@ abstract class AsyncRewriterBase extends ContinuationRewriterBase {
ExpressionLifter expressionRewriter;
AsyncRewriterBase(
HelperNodes helper, FunctionNode enclosingFunction, bool syncAsync)
: super(helper, enclosingFunction, syncAsync) {}
AsyncRewriterBase(HelperNodes helper, FunctionNode enclosingFunction)
: super(helper, enclosingFunction) {}
void setupAsyncContinuations(List<Statement> statements) {
expressionRewriter = new ExpressionLifter(this);
@ -904,9 +894,8 @@ abstract class AsyncRewriterBase extends ContinuationRewriterBase {
class AsyncStarFunctionRewriter extends AsyncRewriterBase {
VariableDeclaration controllerVariable;
AsyncStarFunctionRewriter(
HelperNodes helper, FunctionNode enclosingFunction, bool syncAsync)
: super(helper, enclosingFunction, syncAsync);
AsyncStarFunctionRewriter(HelperNodes helper, FunctionNode enclosingFunction)
: super(helper, enclosingFunction);
FunctionNode rewrite() {
var statements = <Statement>[];
@ -1022,9 +1011,8 @@ class AsyncFunctionRewriter extends AsyncRewriterBase {
VariableDeclaration completerVariable;
VariableDeclaration returnVariable;
AsyncFunctionRewriter(
HelperNodes helper, FunctionNode enclosingFunction, bool syncAsync)
: super(helper, enclosingFunction, syncAsync);
AsyncFunctionRewriter(HelperNodes helper, FunctionNode enclosingFunction)
: super(helper, enclosingFunction);
FunctionNode rewrite() {
var statements = <Statement>[];
@ -1042,28 +1030,16 @@ class AsyncFunctionRewriter extends AsyncRewriterBase {
new InterfaceType(helper.futureOrClass, <DartType>[valueType]);
var completerTypeArguments = <DartType>[valueType];
if (syncAsync) {
final completerType = new InterfaceType(
helper.asyncAwaitCompleterClass, completerTypeArguments);
// final Completer<T> :async_completer = new _AsyncAwaitCompleter<T>();
completerVariable = new VariableDeclaration(":async_completer",
initializer: new ConstructorInvocation(
helper.asyncAwaitCompleterConstructor,
new Arguments([], types: completerTypeArguments))
..fileOffset = enclosingFunction.body?.fileOffset ?? -1,
isFinal: true,
type: completerType);
} else {
final completerType =
new InterfaceType(helper.completerClass, completerTypeArguments);
// final Completer<T> :async_completer = new Completer<T>.sync();
completerVariable = new VariableDeclaration(":async_completer",
initializer: new StaticInvocation(helper.completerConstructor,
new Arguments([], types: completerTypeArguments))
..fileOffset = enclosingFunction.body?.fileOffset ?? -1,
isFinal: true,
type: completerType);
}
final completerType = new InterfaceType(
helper.asyncAwaitCompleterClass, completerTypeArguments);
// final Completer<T> :async_completer = new _AsyncAwaitCompleter<T>();
completerVariable = new VariableDeclaration(":async_completer",
initializer: new ConstructorInvocation(
helper.asyncAwaitCompleterConstructor,
new Arguments([], types: completerTypeArguments))
..fileOffset = enclosingFunction.body?.fileOffset ?? -1,
isFinal: true,
type: completerType);
statements.add(completerVariable);
returnVariable = new VariableDeclaration(":return_value", type: returnType);
@ -1071,23 +1047,13 @@ class AsyncFunctionRewriter extends AsyncRewriterBase {
setupAsyncContinuations(statements);
if (syncAsync) {
// :async_completer.start(:async_op);
var startStatement = new ExpressionStatement(new MethodInvocation(
new VariableGet(completerVariable),
new Name('start'),
new Arguments([new VariableGet(nestedClosureVariable)]))
..fileOffset = enclosingFunction.fileOffset);
statements.add(startStatement);
} else {
// new Future.microtask(:async_op);
var newMicrotaskStatement = new ExpressionStatement(new StaticInvocation(
helper.futureMicrotaskConstructor,
new Arguments([new VariableGet(nestedClosureVariable)],
types: [const DynamicType()]))
..fileOffset = enclosingFunction.fileOffset);
statements.add(newMicrotaskStatement);
}
// :async_completer.start(:async_op);
var startStatement = new ExpressionStatement(new MethodInvocation(
new VariableGet(completerVariable),
new Name('start'),
new Arguments([new VariableGet(nestedClosureVariable)]))
..fileOffset = enclosingFunction.fileOffset);
statements.add(startStatement);
// return :async_completer.future;
var completerGet = new VariableGet(completerVariable);
var returnStatement = new ReturnStatement(new PropertyGet(completerGet,
@ -1152,22 +1118,16 @@ class HelperNodes {
final Member asyncStarMoveNextHelper;
final Procedure asyncThenWrapper;
final Procedure awaitHelper;
final Class completerClass;
final Class asyncAwaitCompleterClass;
final Member completerComplete;
final Member completerCompleteError;
final Member completerConstructor;
final Member asyncAwaitCompleterConstructor;
final Member completeOnAsyncReturn;
final Member completerFuture;
final Library coreLibrary;
final CoreTypes coreTypes;
final Class futureClass;
final Procedure futureMicrotaskConstructor;
final Class futureOrClass;
final Class iterableClass;
final Class iteratorClass;
final Procedure printProcedure;
final Class streamClass;
final Member streamIteratorCancel;
final Class streamIteratorClass;
@ -1196,22 +1156,16 @@ class HelperNodes {
this.asyncStarMoveNextHelper,
this.asyncThenWrapper,
this.awaitHelper,
this.completerClass,
this.asyncAwaitCompleterClass,
this.completerComplete,
this.completerCompleteError,
this.completerConstructor,
this.asyncAwaitCompleterConstructor,
this.completeOnAsyncReturn,
this.completerFuture,
this.coreLibrary,
this.coreTypes,
this.futureClass,
this.futureMicrotaskConstructor,
this.futureOrClass,
this.iterableClass,
this.iteratorClass,
this.printProcedure,
this.streamClass,
this.streamIteratorCancel,
this.streamIteratorClass,
@ -1241,22 +1195,16 @@ class HelperNodes {
coreTypes.asyncStarMoveNextHelper,
coreTypes.asyncThenWrapperHelperProcedure,
coreTypes.awaitHelperProcedure,
coreTypes.completerClass,
coreTypes.asyncAwaitCompleterClass,
coreTypes.completerComplete,
coreTypes.completerCompleteError,
coreTypes.completerSyncConstructor,
coreTypes.asyncAwaitCompleterConstructor,
coreTypes.completeOnAsyncReturn,
coreTypes.completerFuture,
coreTypes.coreLibrary,
coreTypes,
coreTypes.futureClass,
coreTypes.futureMicrotaskConstructor,
coreTypes.futureOrClass,
coreTypes.iterableClass,
coreTypes.iteratorClass,
coreTypes.printProcedure,
coreTypes.streamClass,
coreTypes.streamIteratorCancel,
coreTypes.streamIteratorClass,

4
pkg/vm/lib/target/vm.dart
View file

@ -76,7 +76,7 @@ class VmTarget extends Target {
logger?.call("Transformed mixin applications");
// TODO(kmillikin): Make this run on a per-method basis.
transformAsync.transformLibraries(coreTypes, libraries, flags.syncAsync);
transformAsync.transformLibraries(coreTypes, libraries);
logger?.call("Transformed async methods");
listFactorySpecializer.transformLibraries(libraries, coreTypes);
@ -90,7 +90,7 @@ class VmTarget extends Target {
void performTransformationsOnProcedure(
CoreTypes coreTypes, ClassHierarchy hierarchy, Procedure procedure,
{void logger(String msg)}) {
transformAsync.transformProcedure(coreTypes, procedure, flags.syncAsync);
transformAsync.transformProcedure(coreTypes, procedure);
logger?.call("Transformed async functions");
}

2
utils/bazel/kernel_worker.dart
View file

@ -132,7 +132,7 @@ Future<bool> computeKernel(List<String> args,
Target target;
var summaryOnly = parsedArgs['summary-only'] as bool;
var excludeNonSources = parsedArgs['exclude-non-sources'] as bool;
var targetFlags = new TargetFlags(syncAsync: true);
var targetFlags = new TargetFlags();
if (summaryOnly) {
target = new SummaryTarget(sources, excludeNonSources, targetFlags);
} else {