mirror of
https://github.com/dart-lang/sdk
synced 2024-11-02 10:10:22 +00:00
Reland "[pkg/vm] Handle switch statements in unreachable code eliminator."
This is a reland of commit262311772bWhen running with sound null safety, reducing a logical expression to the right hand side if the left hand side is constant and does not short circuit is valid, as the right hand side is guaranteed not to evaluate to null. In other modes, however, the right hand side may evaluate to null. Thus, in thos modes, we return the original node if the RHS is not a constant boolean value, so that the operator can perform whatever null checking is required. Fixes: https://github.com/dart-lang/sdk/issues/54029 Original change's description: > Reland "[pkg/vm] Handle switch statements in unreachable code eliminator." > > This is a reland of commit92bf76d9e8> > In the original CL, the changes to the UCE assumed all > SwitchStatements were exhaustive. Now if a SwitchStatement isn't > explicitly or implicitly (via a default case) exhaustive and no case > matches the tested constant, the SwitchStatement is properly removed. > > In addition, if a guaranteed to match case is found, more than one > cases remain (thus the SwitchStatement is not removed or replaced with > the single case's body), and the default case is removed, then the > resulting SwitchStatement is marked as explicitly exhaustive, as this > serves as a signal to backends that they do not need to handle the > possibility of no case matching in the absence of a default case. > > Original change's description: > > [pkg/vm] Handle switch statements in unreachable code eliminator. > > > > Namely, if the tested expression for a switch statement is constant, > > then we can remove any constant cases where the constants differ, > > and if all but a single case is removed, we can replace the switch > > with the case body. > > > > If constant functions are not enabled, then getters annotated with > > @pragma("vm:platform-const") are still evaluated with the constant > > function evaluation machinery, but only those and no others (including > > any functions called within an annotated getter). This way, functions > > can be annotated with @pragma("vm:platform-const") without having to > > rewrite them to be a single returned expression. > > > > TEST=pkg/vm/test/transformations/unreachable_code_elimination > > pkg/vm/test/transformations/vm_constant_evaluator > > > > Issue: https://github.com/dart-lang/sdk/issues/50473 > > Issue: https://github.com/dart-lang/sdk/issues/31969 > > Change-Id: Ie290d2f1f469326238d66c3d9631f8e696685ff0 > > Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/332760 > > Commit-Queue: Tess Strickland <sstrickl@google.com> > > Reviewed-by: Chloe Stefantsova <cstefantsova@google.com> > > Reviewed-by: Alexander Markov <alexmarkov@google.com> > > TEST=pkg/vm/test/transformations/unreachable_code_elimination > pkg/vm/test/transformations/vm_constant_evaluator > > Issue: https://github.com/dart-lang/sdk/issues/50473 > Issue: https://github.com/dart-lang/sdk/issues/31969 > Cq-Include-Trybots: luci.dart.try:vm-aot-linux-release-x64-try,vm-aot-mac-release-arm64-try > Change-Id: I557ca933808012e670e306f2d880221a0d7dd670 > Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/334224 > Reviewed-by: Chloe Stefantsova <cstefantsova@google.com> > Reviewed-by: Alexander Markov <alexmarkov@google.com> > Commit-Queue: Tess Strickland <sstrickl@google.com> TEST=pkg/vm/test/transformations/unreachable_code_elimination pkg/vm/test/transformations/vm_constant_evaluator Change-Id: Ia51b7c5f3b51f57a6a306551fe74b47e0cba3c23 Cq-Include-Trybots: luci.dart.try:vm-aot-linux-release-x64-try,vm-aot-mac-release-arm64-try,vm-kernel-precomp-linux-release-x64-try,vm-kernel-linux-release-x64-try Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/335828 Reviewed-by: Chloe Stefantsova <cstefantsova@google.com> Reviewed-by: Alexander Markov <alexmarkov@google.com> Commit-Queue: Tess Strickland <sstrickl@google.com>
This commit is contained in:
Tess Strickland
Commit Queue
parent
2c4a1354e1
commit
4bedb142d3
15 changed files with 1241 additions and 177 deletions
|
|
@ -2638,6 +2638,11 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
|
|||
|
||||
/// Execute a function body using the [StatementConstantEvaluator].
|
||||
Constant executeBody(Statement statement) {
|
||||
if (!enableConstFunctions && !inExtensionTypeConstConstructor) {
|
||||
throw new UnsupportedError("Statement evaluation is only supported when "
|
||||
"in extension type const constructors or when the const functions "
|
||||
"feature is enabled.");
|
||||
}
|
||||
StatementConstantEvaluator statementEvaluator =
|
||||
new StatementConstantEvaluator(this);
|
||||
ExecutionStatus status = statement.accept(statementEvaluator);
|
||||
|
|
@ -2664,6 +2669,11 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
|
|||
/// Returns [null] on success and an error-"constant" on failure, as such the
|
||||
/// return value should be checked.
|
||||
AbortConstant? executeConstructorBody(Constructor constructor) {
|
||||
if (!enableConstFunctions && !inExtensionTypeConstConstructor) {
|
||||
throw new UnsupportedError("Statement evaluation is only supported when "
|
||||
"in extension type const constructors or when the const functions "
|
||||
"feature is enabled.");
|
||||
}
|
||||
final Statement body = constructor.function.body!;
|
||||
StatementConstantEvaluator statementEvaluator =
|
||||
new StatementConstantEvaluator(this);
|
||||
|
|
@ -5485,14 +5495,7 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
|
|||
class StatementConstantEvaluator implements StatementVisitor<ExecutionStatus> {
|
||||
ConstantEvaluator exprEvaluator;
|
||||
|
||||
StatementConstantEvaluator(this.exprEvaluator) {
|
||||
if (!exprEvaluator.enableConstFunctions &&
|
||||
!exprEvaluator.inExtensionTypeConstConstructor) {
|
||||
throw new UnsupportedError("Statement evaluation is only supported when "
|
||||
"in inline class const constructors or when the const functions "
|
||||
"feature is enabled.");
|
||||
}
|
||||
}
|
||||
StatementConstantEvaluator(this.exprEvaluator);
|
||||
|
||||
/// Evaluate the expression using the [ConstantEvaluator].
|
||||
Constant evaluate(Expression expr) => expr.accept(exprEvaluator);
|
||||
|
|
|
|||
|
|
@ -579,7 +579,7 @@ Future runGlobalTransformations(
|
|||
target, component, os, nnbdMode,
|
||||
environmentDefines: environmentDefines, coreTypes: coreTypes);
|
||||
unreachable_code_elimination.transformComponent(
|
||||
component, enableAsserts, evaluator);
|
||||
target, component, evaluator, enableAsserts);
|
||||
|
||||
if (useGlobalTypeFlowAnalysis) {
|
||||
globalTypeFlow.transformComponent(target, coreTypes, component,
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
// BSD-style license that can be found in the LICENSE file.
|
||||
|
||||
import 'package:kernel/ast.dart';
|
||||
import 'package:kernel/target/targets.dart' show Target;
|
||||
import 'package:kernel/type_environment.dart' show StaticTypeContext;
|
||||
|
||||
import 'vm_constant_evaluator.dart' show VMConstantEvaluator;
|
||||
|
|
@ -13,19 +14,23 @@ import 'vm_constant_evaluator.dart' show VMConstantEvaluator;
|
|||
///
|
||||
/// Also performs some additional constant evaluation via [evaluator], which is
|
||||
/// applied to certain types of expressions (currently only StaticGet).
|
||||
Component transformComponent(
|
||||
Component component, bool enableAsserts, VMConstantEvaluator evaluator) {
|
||||
SimpleUnreachableCodeElimination(enableAsserts, evaluator)
|
||||
Component transformComponent(Target target, Component component,
|
||||
VMConstantEvaluator evaluator, bool enableAsserts) {
|
||||
SimpleUnreachableCodeElimination(evaluator,
|
||||
enableAsserts: enableAsserts,
|
||||
soundNullSafety: target.flags.soundNullSafety)
|
||||
.visitComponent(component, null);
|
||||
return component;
|
||||
}
|
||||
|
||||
class SimpleUnreachableCodeElimination extends RemovingTransformer {
|
||||
final bool soundNullSafety;
|
||||
final bool enableAsserts;
|
||||
final VMConstantEvaluator constantEvaluator;
|
||||
StaticTypeContext? _staticTypeContext;
|
||||
|
||||
SimpleUnreachableCodeElimination(this.enableAsserts, this.constantEvaluator);
|
||||
SimpleUnreachableCodeElimination(this.constantEvaluator,
|
||||
{required this.enableAsserts, required this.soundNullSafety});
|
||||
|
||||
@override
|
||||
TreeNode defaultMember(Member node, TreeNode? removalSentinel) {
|
||||
|
|
@ -36,25 +41,32 @@ class SimpleUnreachableCodeElimination extends RemovingTransformer {
|
|||
return result;
|
||||
}
|
||||
|
||||
bool _isBoolConstant(Expression node) =>
|
||||
node is BoolLiteral ||
|
||||
(node is ConstantExpression && node.constant is BoolConstant);
|
||||
|
||||
bool _getBoolConstantValue(Expression node) {
|
||||
if (node is BoolLiteral) {
|
||||
return node.value;
|
||||
}
|
||||
if (node is ConstantExpression) {
|
||||
final constant = node.constant;
|
||||
if (constant is BoolConstant) {
|
||||
return constant.value;
|
||||
}
|
||||
}
|
||||
throw 'Expected bool constant: $node';
|
||||
bool? _getBoolConstantValue(Expression node) {
|
||||
if (node is BoolLiteral) return node.value;
|
||||
if (node is! ConstantExpression) return null;
|
||||
final constant = node.constant;
|
||||
return constant is BoolConstant ? constant.value : null;
|
||||
}
|
||||
|
||||
Expression _createBoolLiteral(bool value, int fileOffset) =>
|
||||
new BoolLiteral(value)..fileOffset = fileOffset;
|
||||
Expression _makeConstantExpression(Constant constant, Expression node) {
|
||||
if (constant is UnevaluatedConstant &&
|
||||
constant.expression is InvalidExpression) {
|
||||
return constant.expression;
|
||||
}
|
||||
ConstantExpression constantExpression = new ConstantExpression(
|
||||
constant, node.getStaticType(_staticTypeContext!))
|
||||
..fileOffset = node.fileOffset;
|
||||
if (node is FileUriExpression) {
|
||||
return new FileUriConstantExpression(constantExpression.constant,
|
||||
type: constantExpression.type, fileUri: node.fileUri)
|
||||
..fileOffset = node.fileOffset;
|
||||
}
|
||||
return constantExpression;
|
||||
}
|
||||
|
||||
Expression _createBoolConstantExpression(bool value, Expression node) =>
|
||||
_makeConstantExpression(
|
||||
constantEvaluator.canonicalize(BoolConstant(value)), node);
|
||||
|
||||
Statement _makeEmptyBlockIfEmptyStatement(Statement node, TreeNode parent) =>
|
||||
node is EmptyStatement ? (Block(<Statement>[])..parent = parent) : node;
|
||||
|
|
@ -63,8 +75,8 @@ class SimpleUnreachableCodeElimination extends RemovingTransformer {
|
|||
TreeNode visitIfStatement(IfStatement node, TreeNode? removalSentinel) {
|
||||
node.transformOrRemoveChildren(this);
|
||||
final condition = node.condition;
|
||||
if (_isBoolConstant(condition)) {
|
||||
final value = _getBoolConstantValue(condition);
|
||||
final value = _getBoolConstantValue(condition);
|
||||
if (value != null) {
|
||||
return value
|
||||
? node.then
|
||||
: (node.otherwise ?? removalSentinel ?? new EmptyStatement());
|
||||
|
|
@ -78,8 +90,8 @@ class SimpleUnreachableCodeElimination extends RemovingTransformer {
|
|||
ConditionalExpression node, TreeNode? removalSentinel) {
|
||||
node.transformOrRemoveChildren(this);
|
||||
final condition = node.condition;
|
||||
if (_isBoolConstant(condition)) {
|
||||
final value = _getBoolConstantValue(condition);
|
||||
final value = _getBoolConstantValue(condition);
|
||||
if (value != null) {
|
||||
return value ? node.then : node.otherwise;
|
||||
}
|
||||
return node;
|
||||
|
|
@ -89,9 +101,9 @@ class SimpleUnreachableCodeElimination extends RemovingTransformer {
|
|||
TreeNode visitNot(Not node, TreeNode? removalSentinel) {
|
||||
node.transformOrRemoveChildren(this);
|
||||
final operand = node.operand;
|
||||
if (_isBoolConstant(operand)) {
|
||||
return _createBoolLiteral(
|
||||
!_getBoolConstantValue(operand), node.fileOffset);
|
||||
final value = _getBoolConstantValue(operand);
|
||||
if (value != null) {
|
||||
return _createBoolConstantExpression(!value, node);
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
|
@ -100,47 +112,118 @@ class SimpleUnreachableCodeElimination extends RemovingTransformer {
|
|||
TreeNode visitLogicalExpression(
|
||||
LogicalExpression node, TreeNode? removalSentinel) {
|
||||
node.transformOrRemoveChildren(this);
|
||||
final left = node.left;
|
||||
final right = node.right;
|
||||
final operatorEnum = node.operatorEnum;
|
||||
if (_isBoolConstant(left)) {
|
||||
final leftValue = _getBoolConstantValue(left);
|
||||
if (_isBoolConstant(right)) {
|
||||
final rightValue = _getBoolConstantValue(right);
|
||||
if (operatorEnum == LogicalExpressionOperator.OR) {
|
||||
return _createBoolLiteral(leftValue || rightValue, node.fileOffset);
|
||||
} else if (operatorEnum == LogicalExpressionOperator.AND) {
|
||||
return _createBoolLiteral(leftValue && rightValue, node.fileOffset);
|
||||
} else {
|
||||
throw 'Unexpected LogicalExpression operator ${operatorEnum}: $node';
|
||||
}
|
||||
} else {
|
||||
if (leftValue && operatorEnum == LogicalExpressionOperator.OR) {
|
||||
return _createBoolLiteral(true, node.fileOffset);
|
||||
} else if (!leftValue &&
|
||||
operatorEnum == LogicalExpressionOperator.AND) {
|
||||
return _createBoolLiteral(false, node.fileOffset);
|
||||
bool? value = _getBoolConstantValue(node.left);
|
||||
// Because of short-circuiting, these operators cannot be treated as
|
||||
// symmetric, so a non-constant left and a constant right is left as-is.
|
||||
if (value == null) return node;
|
||||
// If the RHS is not a known constant and may evaluate to null, then
|
||||
// we must keep the whole node if the LHS does not short circuit, as the
|
||||
// operator performs a null check on the RHS value.
|
||||
final evaluateRight =
|
||||
soundNullSafety || _getBoolConstantValue(node.right) != null
|
||||
? node.right
|
||||
: node;
|
||||
switch (node.operatorEnum) {
|
||||
case LogicalExpressionOperator.OR:
|
||||
return value ? node.left : evaluateRight;
|
||||
case LogicalExpressionOperator.AND:
|
||||
return value ? evaluateRight : node.left;
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
TreeNode visitSwitchStatement(
|
||||
SwitchStatement node, TreeNode? removalSentinel) {
|
||||
node.transformOrRemoveChildren(this);
|
||||
final tested = node.expression;
|
||||
if (tested is! ConstantExpression) return node;
|
||||
|
||||
// First, keep any reachable case. As a side effect, any expressions that
|
||||
// cannot match in the SwitchCases are removed. An expression cannot match
|
||||
// if it is a non-matching constant expression or it follows a constant
|
||||
// expression that is guaranteed to match.
|
||||
final toKeep = <SwitchCase>{};
|
||||
bool foundMatchingCase = false;
|
||||
for (final c in node.cases) {
|
||||
if (foundMatchingCase) {
|
||||
c.expressions.clear();
|
||||
continue;
|
||||
}
|
||||
c.expressions.retainWhere((e) {
|
||||
if (foundMatchingCase) return false;
|
||||
if (e is! ConstantExpression) return true;
|
||||
foundMatchingCase = e.constant == tested.constant;
|
||||
return foundMatchingCase;
|
||||
});
|
||||
if (c.isDefault || c.expressions.isNotEmpty) {
|
||||
toKeep.add(c);
|
||||
}
|
||||
}
|
||||
|
||||
if (toKeep.isEmpty) {
|
||||
if (node.isExhaustive) {
|
||||
throw 'Expected at least one kept case from exhaustive switch: $node';
|
||||
}
|
||||
return removalSentinel ?? new EmptyStatement();
|
||||
}
|
||||
|
||||
// Now iteratively find additional cases to keep by following targets of
|
||||
// continue statements in kept cases.
|
||||
final worklist = [...toKeep];
|
||||
final collector = ContinueSwitchStatementTargetCollector(node);
|
||||
while (worklist.isNotEmpty) {
|
||||
final next = worklist.removeLast();
|
||||
final targets = collector.collectTargets(next);
|
||||
for (final target in targets) {
|
||||
if (toKeep.add(target)) {
|
||||
worklist.add(target);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Finally, remove any cases not marked for keeping. If only one case
|
||||
// is kept, then the switch statement can be replaced with its body.
|
||||
if (toKeep.length == 1) {
|
||||
return toKeep.first.body;
|
||||
}
|
||||
node.cases.retainWhere(toKeep.contains);
|
||||
if (foundMatchingCase && !node.hasDefault) {
|
||||
// While the expression may not be explicitly exhaustive for the type
|
||||
// of the tested expression, it is guaranteed to execute at least one
|
||||
// of the remaining cases, so the backends don't need to handle the case
|
||||
// where no listed case is hit for this switch.
|
||||
//
|
||||
// If the original program has the matching case directly falls through
|
||||
// to the default case for some reason:
|
||||
//
|
||||
// switch (4) {
|
||||
// ...
|
||||
// case 4:
|
||||
// default:
|
||||
// ...
|
||||
// }
|
||||
//
|
||||
// this means the default case is kept despite finding a guaranteed to
|
||||
// match expression, as it contains that matching expression. If that
|
||||
// happens, then we don't do this, to keep the invariant that
|
||||
// isExplicitlyExhaustive is false if there is a default case.
|
||||
node.isExplicitlyExhaustive = true;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
@override
|
||||
visitStaticGet(StaticGet node, TreeNode? removalSentinel) {
|
||||
TreeNode visitStaticGet(StaticGet node, TreeNode? removalSentinel) {
|
||||
node.transformOrRemoveChildren(this);
|
||||
final target = node.target;
|
||||
if (target is Field && target.isConst) {
|
||||
throw 'StaticGet from const field $target should be evaluated by front-end: $node';
|
||||
}
|
||||
if (constantEvaluator.transformerShouldEvaluateExpression(node)) {
|
||||
final context = _staticTypeContext!;
|
||||
final result = constantEvaluator.evaluate(context, node);
|
||||
assert(result is! UnevaluatedConstant);
|
||||
return new ConstantExpression(result, node.getStaticType(context))
|
||||
..fileOffset = node.fileOffset;
|
||||
if (!constantEvaluator.transformerShouldEvaluateExpression(node)) {
|
||||
return node;
|
||||
}
|
||||
return node;
|
||||
final result = constantEvaluator.evaluate(_staticTypeContext!, node);
|
||||
return _makeConstantExpression(result, node);
|
||||
}
|
||||
|
||||
@override
|
||||
|
|
@ -235,3 +318,25 @@ class SimpleUnreachableCodeElimination extends RemovingTransformer {
|
|||
return node;
|
||||
}
|
||||
}
|
||||
|
||||
class ContinueSwitchStatementTargetCollector extends RecursiveVisitor {
|
||||
final SwitchStatement parent;
|
||||
late Set<SwitchCase> collected;
|
||||
|
||||
ContinueSwitchStatementTargetCollector(this.parent);
|
||||
|
||||
Set<SwitchCase> collectTargets(SwitchCase node) {
|
||||
collected = {};
|
||||
node.accept(this);
|
||||
return collected;
|
||||
}
|
||||
|
||||
@override
|
||||
void visitContinueSwitchStatement(ContinueSwitchStatement node) {
|
||||
node.visitChildren(this);
|
||||
// Only keep targets that are within the original node being checked.
|
||||
if (node.target.parent == parent) {
|
||||
collected.add(node.target);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,10 +13,14 @@ import 'package:front_end/src/base/nnbd_mode.dart';
|
|||
import 'package:front_end/src/fasta/kernel/constant_evaluator.dart'
|
||||
show
|
||||
AbortConstant,
|
||||
AbortStatus,
|
||||
ConstantEvaluator,
|
||||
ErrorReporter,
|
||||
EvaluationMode,
|
||||
SimpleErrorReporter;
|
||||
ProceedStatus,
|
||||
ReturnStatus,
|
||||
SimpleErrorReporter,
|
||||
StatementConstantEvaluator;
|
||||
|
||||
import '../target_os.dart';
|
||||
|
||||
|
|
@ -26,8 +30,10 @@ import '../target_os.dart';
|
|||
/// [targetOS] represents the target operating system and is used when
|
||||
/// evaluating static fields and getters annotated with "vm:platform-const".
|
||||
///
|
||||
/// If [enableConstFunctions] is false, then only getters that return the
|
||||
/// result of a single expression can be evaluated.
|
||||
/// To avoid restricting getters annotated with "vm:platform-const" to be just
|
||||
/// a single return statement whose body is evaluated, we treat annotated
|
||||
/// getters as const functions. If [enableConstFunctions] is false, then
|
||||
/// only annotated getters are treated this way.
|
||||
class VMConstantEvaluator extends ConstantEvaluator {
|
||||
final TargetOS? _targetOS;
|
||||
final Map<String, Constant> _constantFields = {};
|
||||
|
|
@ -124,6 +130,19 @@ class VMConstantEvaluator extends ConstantEvaluator {
|
|||
bool transformerShouldEvaluateExpression(Expression node) =>
|
||||
_targetOS != null && node is StaticGet && _isPlatformConst(node.target);
|
||||
|
||||
Constant _executePlatformConstBody(Statement statement) {
|
||||
final status = statement.accept(StatementConstantEvaluator(this));
|
||||
if (status is AbortStatus) return status.error;
|
||||
// Happens if there is no return statement in a void Function(...) body.
|
||||
if (status is ProceedStatus) return canonicalize(NullConstant());
|
||||
if (status is ReturnStatus) {
|
||||
final value = status.value;
|
||||
return value != null ? value : canonicalize(NullConstant());
|
||||
}
|
||||
// Other statuses denote intermediate states and not final ones.
|
||||
throw 'No valid constant returned after executing $statement';
|
||||
}
|
||||
|
||||
@override
|
||||
Constant visitStaticGet(StaticGet node) {
|
||||
assert(_targetOS != null);
|
||||
|
|
@ -153,20 +172,7 @@ class VMConstantEvaluator extends ConstantEvaluator {
|
|||
result = evaluateExpressionInContext(target, target.initializer!);
|
||||
} else if (target is Procedure && target.isGetter) {
|
||||
final body = target.function.body!;
|
||||
// If const functions are enabled, execute the getter as if it were
|
||||
// a const function. Otherwise the annotated getter must be a single
|
||||
// return statement whose expression is evaluated.
|
||||
if (enableConstFunctions) {
|
||||
result = executeBody(body);
|
||||
} else if (body is ReturnStatement) {
|
||||
if (body.expression == null) {
|
||||
return canonicalize(NullConstant());
|
||||
}
|
||||
result = evaluateExpressionInContext(target, body.expression!);
|
||||
} else {
|
||||
throw "Cannot evaluate method '$nameText' since it contains more "
|
||||
"than a single return statement.";
|
||||
}
|
||||
result = _executePlatformConstBody(body);
|
||||
}
|
||||
if (result is AbortConstant) {
|
||||
throw "The body or initialization of member '$nameText' does not "
|
||||
|
|
|
|||
|
|
@ -20,19 +20,23 @@ import '../common_test_utils.dart';
|
|||
final String pkgVmDir = Platform.script.resolve('../..').toFilePath();
|
||||
|
||||
runTestCase(Uri source) async {
|
||||
final target = new VmTarget(new TargetFlags());
|
||||
// Do not perform constant evaluation for a specific target operating system.
|
||||
final targetOS = null;
|
||||
final enableAsserts = false;
|
||||
final soundNullSafety = true;
|
||||
final nnbdMode = NnbdMode.Strong;
|
||||
|
||||
final target =
|
||||
new VmTarget(new TargetFlags(soundNullSafety: soundNullSafety));
|
||||
Component component = await compileTestCaseToKernelProgram(source,
|
||||
target: target,
|
||||
environmentDefines: {
|
||||
'test.define.isTrue': 'true',
|
||||
'test.define.isFalse': 'false'
|
||||
});
|
||||
|
||||
// Do not perform constant evaluation for a specific target operating system.
|
||||
final evaluator = VMConstantEvaluator.create(
|
||||
target, component, /* targetOS = */ null, NnbdMode.Strong);
|
||||
component =
|
||||
transformComponent(component, /* enableAsserts = */ false, evaluator);
|
||||
final evaluator =
|
||||
VMConstantEvaluator.create(target, component, targetOS, nnbdMode);
|
||||
component = transformComponent(target, component, evaluator, enableAsserts);
|
||||
verifyComponent(
|
||||
target, VerificationStage.afterGlobalTransformations, component);
|
||||
|
||||
|
|
|
|||
|
|
@ -21,8 +21,12 @@ import '../common_test_utils.dart';
|
|||
|
||||
final String pkgVmDir = Platform.script.resolve('../..').toFilePath();
|
||||
|
||||
runTestCase(Uri source, TargetOS os) async {
|
||||
final target = new VmTarget(new TargetFlags());
|
||||
runTestCase(Uri source, TargetOS os, String postfix) async {
|
||||
final enableAsserts = false;
|
||||
final soundNullSafety = true;
|
||||
final nnbdMode = NnbdMode.Strong;
|
||||
final target =
|
||||
new VmTarget(new TargetFlags(soundNullSafety: soundNullSafety));
|
||||
Component component = await compileTestCaseToKernelProgram(source,
|
||||
target: target,
|
||||
environmentDefines: {
|
||||
|
|
@ -30,15 +34,12 @@ runTestCase(Uri source, TargetOS os) async {
|
|||
'test.define.isFalse': 'false'
|
||||
});
|
||||
|
||||
final evaluator =
|
||||
VMConstantEvaluator.create(target, component, os, NnbdMode.Strong);
|
||||
final enableAsserts = false;
|
||||
component = transformComponent(component, enableAsserts, evaluator);
|
||||
final evaluator = VMConstantEvaluator.create(target, component, os, nnbdMode);
|
||||
component = transformComponent(target, component, evaluator, enableAsserts);
|
||||
verifyComponent(
|
||||
target, VerificationStage.afterGlobalTransformations, component);
|
||||
|
||||
final actual = kernelLibraryToString(component.mainMethod!.enclosingLibrary);
|
||||
final postfix = '.${os.name}';
|
||||
compareResultWithExpectationsFile(source, actual, expectFilePostfix: postfix);
|
||||
}
|
||||
|
||||
|
|
@ -52,7 +53,9 @@ main() {
|
|||
.reversed) {
|
||||
if (entry.path.endsWith(".dart")) {
|
||||
for (final os in TargetOS.values) {
|
||||
test('${entry.path}.${os.name}', () => runTestCase(entry.uri, os));
|
||||
final postfix = '.${os.name}';
|
||||
test('${entry.path}$postfix',
|
||||
() => runTestCase(entry.uri, os, postfix));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,6 +9,8 @@ const bool constFalse2 = const bool.fromEnvironment('test.define.notDefined');
|
|||
|
||||
bool? foo() => null;
|
||||
|
||||
Never throws() => throw 'oops';
|
||||
|
||||
void testSimpleConditions() {
|
||||
if (constTrue) {
|
||||
print('1_yes');
|
||||
|
|
@ -25,6 +27,7 @@ void testSimpleConditions() {
|
|||
}
|
||||
|
||||
void testAndConditions() {
|
||||
// LHS and operator should only be dropped with sound null safety.
|
||||
if (constTrue && foo()!) {
|
||||
print('1_yes');
|
||||
}
|
||||
|
|
@ -37,12 +40,19 @@ void testAndConditions() {
|
|||
if (constTrue && constTrue && constFalse) {
|
||||
print('4_no');
|
||||
}
|
||||
if (throws() && constTrue) {
|
||||
print('5_calls_throw');
|
||||
}
|
||||
if (throws() && constFalse) {
|
||||
print('6_calls_throw');
|
||||
}
|
||||
}
|
||||
|
||||
void testOrConditions() {
|
||||
if (constTrue || foo()!) {
|
||||
print('1_yes');
|
||||
}
|
||||
// LHS and operator should only be dropped with sound null safety.
|
||||
if (constFalse || foo()!) {
|
||||
print('2_yes');
|
||||
}
|
||||
|
|
@ -52,6 +62,12 @@ void testOrConditions() {
|
|||
if (constFalse || !constTrue || constTrue2) {
|
||||
print('4_yes');
|
||||
}
|
||||
if (throws() || constTrue) {
|
||||
print('5_calls_throw');
|
||||
}
|
||||
if (throws() || constFalse) {
|
||||
print('6_calls_throw');
|
||||
}
|
||||
}
|
||||
|
||||
void testNotConditions() {
|
||||
|
|
@ -112,6 +128,287 @@ testRemovalOfStatementBodies() {
|
|||
}
|
||||
}
|
||||
|
||||
enum TestPlatform {
|
||||
linux,
|
||||
macos,
|
||||
windows,
|
||||
}
|
||||
|
||||
const switchTestString = "noMatch";
|
||||
const switchTestInt = 23;
|
||||
|
||||
testConstantSwitches() {
|
||||
switch (constTrue) {
|
||||
case true:
|
||||
print('1_yes');
|
||||
break;
|
||||
case false:
|
||||
print('2_no');
|
||||
break;
|
||||
}
|
||||
switch (constFalse) {
|
||||
case true:
|
||||
print('3_yes');
|
||||
break;
|
||||
default:
|
||||
print('4_not_yes');
|
||||
}
|
||||
switch (TestPlatform.windows) {
|
||||
case TestPlatform.linux:
|
||||
print("5_linux");
|
||||
break;
|
||||
case TestPlatform.macos:
|
||||
print("6_macos");
|
||||
break;
|
||||
case TestPlatform.windows:
|
||||
print("7_windows");
|
||||
break;
|
||||
}
|
||||
switch (TestPlatform.macos) {
|
||||
case TestPlatform.linux:
|
||||
case TestPlatform.macos:
|
||||
print("8_not_windows");
|
||||
break;
|
||||
case TestPlatform.windows:
|
||||
print("9_windows");
|
||||
break;
|
||||
}
|
||||
switch (TestPlatform.linux) {
|
||||
case TestPlatform.linux:
|
||||
continue L1_macos;
|
||||
L1_macos:
|
||||
case TestPlatform.macos:
|
||||
print("10_not_windows");
|
||||
break;
|
||||
case TestPlatform.windows:
|
||||
print("11_windows");
|
||||
break;
|
||||
}
|
||||
switch (TestPlatform.windows) {
|
||||
case TestPlatform.linux:
|
||||
print("12_linux");
|
||||
break;
|
||||
case TestPlatform.macos:
|
||||
print("13_macos");
|
||||
break;
|
||||
default:
|
||||
print("14_default");
|
||||
}
|
||||
switch (TestPlatform.windows) {
|
||||
case TestPlatform.linux:
|
||||
print("15_linux");
|
||||
break;
|
||||
case TestPlatform.macos:
|
||||
print("16_macos");
|
||||
break;
|
||||
case TestPlatform.windows:
|
||||
continue L2_default;
|
||||
L2_default:
|
||||
default:
|
||||
print("17_default");
|
||||
}
|
||||
// Not explicitly exhaustive as is because there's a default, but once UCE
|
||||
// is run, the resulting switch should be explicitly exhaustive, as the
|
||||
// default is removed but we're still guaranteed that a case will be matched.
|
||||
switch (TestPlatform.macos) {
|
||||
L3_linux:
|
||||
case TestPlatform.linux:
|
||||
print("18_notwindows");
|
||||
break;
|
||||
case TestPlatform.macos:
|
||||
continue L3_linux;
|
||||
case TestPlatform.windows:
|
||||
print("19_windows");
|
||||
break;
|
||||
default:
|
||||
print("20_default");
|
||||
}
|
||||
// Also should be explicitly exhaustive post-UCE, for the reason above.
|
||||
switch (TestPlatform.macos) {
|
||||
L4_linux:
|
||||
case TestPlatform.linux:
|
||||
print("21_notwindows");
|
||||
break;
|
||||
case TestPlatform.macos:
|
||||
if (foo()!) {
|
||||
continue L4_linux;
|
||||
}
|
||||
break;
|
||||
case TestPlatform.windows:
|
||||
print("22_windows");
|
||||
break;
|
||||
default:
|
||||
print("23_default");
|
||||
}
|
||||
switch (switchTestString) {
|
||||
case "isMatch":
|
||||
print("24_isMatch");
|
||||
break;
|
||||
case "isNotMatch":
|
||||
print("25_isNotMatch");
|
||||
break;
|
||||
default:
|
||||
print("26_default");
|
||||
}
|
||||
switch (switchTestString) {
|
||||
case "isMatch":
|
||||
print("27_isMatch");
|
||||
break;
|
||||
L5_isNotMatch:
|
||||
case "isNotMatch":
|
||||
print("28_isNotMatch");
|
||||
break;
|
||||
default:
|
||||
continue L5_isNotMatch;
|
||||
}
|
||||
switch (switchTestInt) {
|
||||
case 0:
|
||||
print("29_zero");
|
||||
break;
|
||||
case 1:
|
||||
print("30_one");
|
||||
break;
|
||||
default:
|
||||
print("31_default");
|
||||
}
|
||||
switch (switchTestInt) {
|
||||
case 0:
|
||||
print("32_zero");
|
||||
break;
|
||||
case 23:
|
||||
print("33_twentythree");
|
||||
break;
|
||||
default:
|
||||
print("34_default");
|
||||
}
|
||||
switch (switchTestString) {
|
||||
case "foo":
|
||||
switch (switchTestInt) {
|
||||
case 0:
|
||||
print("35_foo_zero");
|
||||
break;
|
||||
default:
|
||||
print("36_foo_nonzero");
|
||||
}
|
||||
break;
|
||||
default:
|
||||
switch (switchTestInt) {
|
||||
case 1:
|
||||
print("37_default_one");
|
||||
break;
|
||||
default:
|
||||
print("38_default_default");
|
||||
}
|
||||
}
|
||||
switch (switchTestString) {
|
||||
L6_foo:
|
||||
case "foo":
|
||||
switch (switchTestInt) {
|
||||
case 0:
|
||||
print("39_foo_zero");
|
||||
break;
|
||||
default:
|
||||
print("40_foo_nonzero");
|
||||
}
|
||||
break;
|
||||
default:
|
||||
switch (switchTestInt) {
|
||||
case 1:
|
||||
print("41_default_one");
|
||||
break;
|
||||
default:
|
||||
continue L6_foo;
|
||||
}
|
||||
}
|
||||
switch (switchTestString) {
|
||||
case "foo":
|
||||
switch (switchTestInt) {
|
||||
case 0:
|
||||
continue L7_default;
|
||||
default:
|
||||
print("42_foo_nonzero");
|
||||
}
|
||||
break;
|
||||
L7_default:
|
||||
default:
|
||||
switch (switchTestInt) {
|
||||
case 23:
|
||||
print("43_default_twentythree");
|
||||
break;
|
||||
default:
|
||||
print("44_default_default");
|
||||
}
|
||||
}
|
||||
switch (switchTestString) {
|
||||
L8_foo:
|
||||
case "foo":
|
||||
switch (switchTestInt) {
|
||||
case 23:
|
||||
continue L9_default;
|
||||
default:
|
||||
print("45_foo_nontwentythree");
|
||||
}
|
||||
break;
|
||||
L9_default:
|
||||
default:
|
||||
switch (switchTestInt) {
|
||||
case 23:
|
||||
print("46_default_twentythree");
|
||||
break;
|
||||
default:
|
||||
continue L8_foo;
|
||||
}
|
||||
}
|
||||
switch (switchTestString) {
|
||||
L10_foo:
|
||||
case "foo":
|
||||
switch (switchTestInt) {
|
||||
case 23:
|
||||
continue L11_default;
|
||||
default:
|
||||
print("47_foo_nontwentythree");
|
||||
}
|
||||
break;
|
||||
L11_default:
|
||||
default:
|
||||
switch (switchTestInt) {
|
||||
case 0:
|
||||
print("48_default_zero");
|
||||
break;
|
||||
default:
|
||||
continue L10_foo;
|
||||
}
|
||||
}
|
||||
switch (switchTestInt) {
|
||||
case 23:
|
||||
print("49_twentythree");
|
||||
}
|
||||
switch (switchTestInt) {
|
||||
case 0:
|
||||
print("50_zero");
|
||||
}
|
||||
switch (switchTestInt) {
|
||||
case 0:
|
||||
print("51_zero");
|
||||
break;
|
||||
case 23:
|
||||
default:
|
||||
print("52_23_and_default");
|
||||
}
|
||||
// Should not be marked as isExplicitlyExhaustive, as the case that has the
|
||||
// matching constant is also the default.
|
||||
switch (switchTestInt) {
|
||||
L12_zero:
|
||||
case 0:
|
||||
print("51_zero");
|
||||
break;
|
||||
case 23:
|
||||
default:
|
||||
print("52_23_and_default");
|
||||
continue L12_zero;
|
||||
}
|
||||
}
|
||||
|
||||
main(List<String> args) {
|
||||
testSimpleConditions();
|
||||
testAndConditions();
|
||||
|
|
|
|||
|
|
@ -6,12 +6,27 @@ class TestAssertInitializer extends core::Object {
|
|||
constructor •() → self::TestAssertInitializer
|
||||
: super core::Object::•() {}
|
||||
}
|
||||
static const field core::bool constTrue = #C1;
|
||||
static const field core::bool constFalse = #C2;
|
||||
static const field core::bool constTrue2 = #C1;
|
||||
static const field core::bool constFalse2 = #C2;
|
||||
class TestPlatform extends core::_Enum /*isEnum*/ {
|
||||
static const field core::List<self::TestPlatform> values = #C10;
|
||||
enum-element static const field self::TestPlatform linux = #C3;
|
||||
enum-element static const field self::TestPlatform macos = #C6;
|
||||
enum-element static const field self::TestPlatform windows = #C9;
|
||||
const synthetic constructor •(core::int #index, core::String #name) → self::TestPlatform
|
||||
: super core::_Enum::•(#index, #name)
|
||||
;
|
||||
method _enumToString() → core::String
|
||||
return "TestPlatform.${this.{core::_Enum::_name}{core::String}}";
|
||||
}
|
||||
static const field core::bool constTrue = #C11;
|
||||
static const field core::bool constFalse = #C12;
|
||||
static const field core::bool constTrue2 = #C11;
|
||||
static const field core::bool constFalse2 = #C12;
|
||||
static const field core::String switchTestString = #C13;
|
||||
static const field core::int switchTestInt = #C14;
|
||||
static method foo() → core::bool?
|
||||
return null;
|
||||
static method throws() → Never
|
||||
return throw "oops";
|
||||
static method testSimpleConditions() → void {
|
||||
{
|
||||
core::print("1_yes");
|
||||
|
|
@ -21,20 +36,32 @@ static method testSimpleConditions() → void {
|
|||
}
|
||||
}
|
||||
static method testAndConditions() → void {
|
||||
if(#C1 && self::foo()!) {
|
||||
if(self::foo()!) {
|
||||
core::print("1_yes");
|
||||
}
|
||||
if(self::throws() && #C11) {
|
||||
core::print("5_calls_throw");
|
||||
}
|
||||
if(self::throws() && #C12) {
|
||||
core::print("6_calls_throw");
|
||||
}
|
||||
}
|
||||
static method testOrConditions() → void {
|
||||
{
|
||||
core::print("1_yes");
|
||||
}
|
||||
if(#C2 || self::foo()!) {
|
||||
if(self::foo()!) {
|
||||
core::print("2_yes");
|
||||
}
|
||||
{
|
||||
core::print("4_yes");
|
||||
}
|
||||
if(self::throws() || #C11) {
|
||||
core::print("5_calls_throw");
|
||||
}
|
||||
if(self::throws() || #C12) {
|
||||
core::print("6_calls_throw");
|
||||
}
|
||||
}
|
||||
static method testNotConditions() → void {
|
||||
{
|
||||
|
|
@ -71,7 +98,7 @@ static method testRemovalOfStatementBodies() → dynamic {
|
|||
#L1:
|
||||
switch(42) /* core::int */ {
|
||||
#L2:
|
||||
case #C3:
|
||||
case #C15:
|
||||
{}
|
||||
}
|
||||
#L3:
|
||||
|
|
@ -81,6 +108,198 @@ static method testRemovalOfStatementBodies() → dynamic {
|
|||
{}
|
||||
}
|
||||
}
|
||||
static method testConstantSwitches() → dynamic {
|
||||
#L5:
|
||||
{
|
||||
core::print("1_yes");
|
||||
break #L5;
|
||||
}
|
||||
#L6:
|
||||
{
|
||||
core::print("4_not_yes");
|
||||
}
|
||||
#L7:
|
||||
{
|
||||
core::print("7_windows");
|
||||
break #L7;
|
||||
}
|
||||
#L8:
|
||||
{
|
||||
core::print("8_not_windows");
|
||||
break #L8;
|
||||
}
|
||||
#L9:
|
||||
switch(#C3) /* isExplicitlyExhaustive, self::TestPlatform */ {
|
||||
#L10:
|
||||
case #C3:
|
||||
{
|
||||
continue #L11;
|
||||
}
|
||||
#L11:
|
||||
{
|
||||
core::print("10_not_windows");
|
||||
break #L9;
|
||||
}
|
||||
}
|
||||
#L12:
|
||||
{
|
||||
core::print("14_default");
|
||||
}
|
||||
#L13:
|
||||
switch(#C9) /* self::TestPlatform */ {
|
||||
#L14:
|
||||
case #C9:
|
||||
{
|
||||
continue #L15;
|
||||
}
|
||||
#L15:
|
||||
default:
|
||||
{
|
||||
core::print("17_default");
|
||||
}
|
||||
}
|
||||
#L16:
|
||||
switch(#C6) /* isExplicitlyExhaustive, self::TestPlatform */ {
|
||||
#L17:
|
||||
{
|
||||
core::print("18_notwindows");
|
||||
break #L16;
|
||||
}
|
||||
#L18:
|
||||
case #C6:
|
||||
{
|
||||
continue #L17;
|
||||
}
|
||||
}
|
||||
#L19:
|
||||
switch(#C6) /* isExplicitlyExhaustive, self::TestPlatform */ {
|
||||
#L20:
|
||||
{
|
||||
core::print("21_notwindows");
|
||||
break #L19;
|
||||
}
|
||||
#L21:
|
||||
case #C6:
|
||||
{
|
||||
if(self::foo()!) {
|
||||
continue #L20;
|
||||
}
|
||||
break #L19;
|
||||
}
|
||||
}
|
||||
#L22:
|
||||
{
|
||||
core::print("26_default");
|
||||
}
|
||||
#L23:
|
||||
switch(#C13) /* core::String */ {
|
||||
#L24:
|
||||
{
|
||||
core::print("28_isNotMatch");
|
||||
break #L23;
|
||||
}
|
||||
#L25:
|
||||
default:
|
||||
{
|
||||
continue #L24;
|
||||
}
|
||||
}
|
||||
#L26:
|
||||
{
|
||||
core::print("31_default");
|
||||
}
|
||||
#L27:
|
||||
{
|
||||
core::print("33_twentythree");
|
||||
break #L27;
|
||||
}
|
||||
#L28:
|
||||
{
|
||||
#L29:
|
||||
{
|
||||
core::print("38_default_default");
|
||||
}
|
||||
}
|
||||
#L30:
|
||||
switch(#C13) /* core::String */ {
|
||||
#L31:
|
||||
{
|
||||
#L32:
|
||||
{
|
||||
core::print("40_foo_nonzero");
|
||||
}
|
||||
break #L30;
|
||||
}
|
||||
#L33:
|
||||
default:
|
||||
{
|
||||
#L34:
|
||||
{
|
||||
continue #L31;
|
||||
}
|
||||
}
|
||||
}
|
||||
#L35:
|
||||
{
|
||||
#L36:
|
||||
{
|
||||
core::print("43_default_twentythree");
|
||||
break #L36;
|
||||
}
|
||||
}
|
||||
#L37:
|
||||
{
|
||||
#L38:
|
||||
{
|
||||
core::print("46_default_twentythree");
|
||||
break #L38;
|
||||
}
|
||||
}
|
||||
#L39:
|
||||
switch(#C13) /* core::String */ {
|
||||
#L40:
|
||||
{
|
||||
#L41:
|
||||
{
|
||||
continue #L42;
|
||||
}
|
||||
break #L39;
|
||||
}
|
||||
#L42:
|
||||
default:
|
||||
{
|
||||
#L43:
|
||||
{
|
||||
continue #L40;
|
||||
}
|
||||
}
|
||||
}
|
||||
#L44:
|
||||
{
|
||||
core::print("49_twentythree");
|
||||
}
|
||||
#L45:
|
||||
;
|
||||
#L46:
|
||||
{
|
||||
core::print("52_23_and_default");
|
||||
}
|
||||
#L47:
|
||||
switch(#C14) /* core::int */ {
|
||||
#L48:
|
||||
{
|
||||
core::print("51_zero");
|
||||
break #L47;
|
||||
}
|
||||
#L49:
|
||||
case #C14:
|
||||
default:
|
||||
{
|
||||
core::print("52_23_and_default");
|
||||
continue #L48;
|
||||
}
|
||||
}
|
||||
}
|
||||
static method main(core::List<core::String> args) → dynamic {
|
||||
self::testSimpleConditions();
|
||||
self::testAndConditions();
|
||||
|
|
@ -92,7 +311,19 @@ static method main(core::List<core::String> args) → dynamic {
|
|||
self::testRemovalOfStatementBodies();
|
||||
}
|
||||
constants {
|
||||
#C1 = true
|
||||
#C2 = false
|
||||
#C3 = 10
|
||||
#C1 = 0
|
||||
#C2 = "linux"
|
||||
#C3 = self::TestPlatform {index:#C1, _name:#C2}
|
||||
#C4 = 1
|
||||
#C5 = "macos"
|
||||
#C6 = self::TestPlatform {index:#C4, _name:#C5}
|
||||
#C7 = 2
|
||||
#C8 = "windows"
|
||||
#C9 = self::TestPlatform {index:#C7, _name:#C8}
|
||||
#C10 = <self::TestPlatform>[#C3, #C6, #C9]
|
||||
#C11 = true
|
||||
#C12 = false
|
||||
#C13 = "noMatch"
|
||||
#C14 = 23
|
||||
#C15 = 10
|
||||
}
|
||||
|
|
|
|||
|
|
@ -70,6 +70,77 @@ void testWindows(int i) {
|
|||
}
|
||||
}
|
||||
|
||||
void testSwitchStatements(int i) {
|
||||
switch (Platform.operatingSystem) {
|
||||
case "android":
|
||||
print("is android");
|
||||
break;
|
||||
case "fuchsia":
|
||||
print("is fuchsia");
|
||||
break;
|
||||
case "ios":
|
||||
print("is ios");
|
||||
break;
|
||||
case "linux":
|
||||
print("is linux");
|
||||
break;
|
||||
case "macos":
|
||||
print("is macos");
|
||||
break;
|
||||
case "windows":
|
||||
print("is windows");
|
||||
break;
|
||||
default:
|
||||
throw "Unexpected platform";
|
||||
}
|
||||
}
|
||||
|
||||
enum TestPlatform {
|
||||
android,
|
||||
fuchsia,
|
||||
ios,
|
||||
linux,
|
||||
macos,
|
||||
windows,
|
||||
}
|
||||
|
||||
@pragma("vm:platform-const")
|
||||
TestPlatform get defaultTestPlatform {
|
||||
if (Platform.isAndroid) return TestPlatform.android;
|
||||
if (Platform.isFuchsia) return TestPlatform.fuchsia;
|
||||
if (Platform.isIOS) return TestPlatform.ios;
|
||||
if (Platform.isLinux) return TestPlatform.linux;
|
||||
if (Platform.isMacOS) return TestPlatform.macos;
|
||||
if (Platform.isWindows) return TestPlatform.windows;
|
||||
throw 'Unexpected platform';
|
||||
}
|
||||
|
||||
void testPragma(int i) {
|
||||
print(defaultTestPlatform);
|
||||
switch (defaultTestPlatform) {
|
||||
case TestPlatform.android:
|
||||
print("is android");
|
||||
break;
|
||||
case TestPlatform.fuchsia:
|
||||
print("is fuchsia");
|
||||
break;
|
||||
case TestPlatform.ios:
|
||||
print("is ios");
|
||||
break;
|
||||
case TestPlatform.linux:
|
||||
print("is linux");
|
||||
break;
|
||||
case TestPlatform.macos:
|
||||
print("is macos");
|
||||
break;
|
||||
case TestPlatform.windows:
|
||||
print("is windows");
|
||||
break;
|
||||
default:
|
||||
throw "Unexpected platform";
|
||||
}
|
||||
}
|
||||
|
||||
main(List<String> args) {
|
||||
if (args.isEmpty) return;
|
||||
final i = int.parse(args[0]);
|
||||
|
|
@ -79,4 +150,6 @@ main(List<String> args) {
|
|||
testLinux(i);
|
||||
testMacOS(i);
|
||||
testWindows(i);
|
||||
testSwitchStatements(i);
|
||||
testPragma(i);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,36 +4,70 @@ import "dart:core" as core;
|
|||
|
||||
import "dart:io";
|
||||
|
||||
class TestPlatform extends core::_Enum /*isEnum*/ {
|
||||
static const field core::List<self::TestPlatform> values = #C19;
|
||||
enum-element static const field self::TestPlatform android = #C3;
|
||||
enum-element static const field self::TestPlatform fuchsia = #C6;
|
||||
enum-element static const field self::TestPlatform ios = #C9;
|
||||
enum-element static const field self::TestPlatform linux = #C12;
|
||||
enum-element static const field self::TestPlatform macos = #C15;
|
||||
enum-element static const field self::TestPlatform windows = #C18;
|
||||
const synthetic constructor •(core::int #index, core::String #name) → self::TestPlatform
|
||||
: super core::_Enum::•(#index, #name)
|
||||
;
|
||||
method _enumToString() → core::String
|
||||
return "TestPlatform.${this.{core::_Enum::_name}{core::String}}";
|
||||
}
|
||||
static method testAndroid(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
{
|
||||
final core::String os = #C2;
|
||||
core::print(os);
|
||||
final core::String sep = #C3;
|
||||
final core::String sep = #C21;
|
||||
core::print(sep);
|
||||
}
|
||||
}
|
||||
static method testFuchsia(core::int i) → void {
|
||||
final core::bool b = #C4;
|
||||
final core::bool b = #C22;
|
||||
core::print(b);
|
||||
}
|
||||
static method testIOS(core::int i) → void {
|
||||
final core::bool b = #C4;
|
||||
final core::bool b = #C22;
|
||||
core::print(b);
|
||||
}
|
||||
static method testLinux(core::int i) → void {
|
||||
final core::bool b = #C4;
|
||||
final core::bool b = #C22;
|
||||
core::print(b);
|
||||
}
|
||||
static method testMacOS(core::int i) → void {
|
||||
final core::bool b = #C4;
|
||||
final core::bool b = #C22;
|
||||
core::print(b);
|
||||
}
|
||||
static method testWindows(core::int i) → void {
|
||||
final core::bool b = #C4;
|
||||
final core::bool b = #C22;
|
||||
core::print(b);
|
||||
}
|
||||
static method testSwitchStatements(core::int i) → void {
|
||||
#L1:
|
||||
{
|
||||
core::print("is android");
|
||||
break #L1;
|
||||
}
|
||||
}
|
||||
@#C25
|
||||
static get defaultTestPlatform() → self::TestPlatform {
|
||||
return #C3;
|
||||
throw "Unexpected platform";
|
||||
}
|
||||
static method testPragma(core::int i) → void {
|
||||
core::print(#C3);
|
||||
#L2:
|
||||
{
|
||||
core::print("is android");
|
||||
break #L2;
|
||||
}
|
||||
}
|
||||
static method main(core::List<core::String> args) → dynamic {
|
||||
if(args.{core::Iterable::isEmpty}{core::bool})
|
||||
return;
|
||||
|
|
@ -44,10 +78,33 @@ static method main(core::List<core::String> args) → dynamic {
|
|||
self::testLinux(i);
|
||||
self::testMacOS(i);
|
||||
self::testWindows(i);
|
||||
self::testSwitchStatements(i);
|
||||
self::testPragma(i);
|
||||
}
|
||||
constants {
|
||||
#C1 = true
|
||||
#C1 = 0
|
||||
#C2 = "android"
|
||||
#C3 = "/"
|
||||
#C4 = false
|
||||
#C3 = self::TestPlatform {index:#C1, _name:#C2}
|
||||
#C4 = 1
|
||||
#C5 = "fuchsia"
|
||||
#C6 = self::TestPlatform {index:#C4, _name:#C5}
|
||||
#C7 = 2
|
||||
#C8 = "ios"
|
||||
#C9 = self::TestPlatform {index:#C7, _name:#C8}
|
||||
#C10 = 3
|
||||
#C11 = "linux"
|
||||
#C12 = self::TestPlatform {index:#C10, _name:#C11}
|
||||
#C13 = 4
|
||||
#C14 = "macos"
|
||||
#C15 = self::TestPlatform {index:#C13, _name:#C14}
|
||||
#C16 = 5
|
||||
#C17 = "windows"
|
||||
#C18 = self::TestPlatform {index:#C16, _name:#C17}
|
||||
#C19 = <self::TestPlatform>[#C3, #C6, #C9, #C12, #C15, #C18]
|
||||
#C20 = true
|
||||
#C21 = "/"
|
||||
#C22 = false
|
||||
#C23 = "vm:platform-const"
|
||||
#C24 = null
|
||||
#C25 = core::pragma {name:#C23, options:#C24}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,36 +4,70 @@ import "dart:core" as core;
|
|||
|
||||
import "dart:io";
|
||||
|
||||
class TestPlatform extends core::_Enum /*isEnum*/ {
|
||||
static const field core::List<self::TestPlatform> values = #C19;
|
||||
enum-element static const field self::TestPlatform android = #C3;
|
||||
enum-element static const field self::TestPlatform fuchsia = #C6;
|
||||
enum-element static const field self::TestPlatform ios = #C9;
|
||||
enum-element static const field self::TestPlatform linux = #C12;
|
||||
enum-element static const field self::TestPlatform macos = #C15;
|
||||
enum-element static const field self::TestPlatform windows = #C18;
|
||||
const synthetic constructor •(core::int #index, core::String #name) → self::TestPlatform
|
||||
: super core::_Enum::•(#index, #name)
|
||||
;
|
||||
method _enumToString() → core::String
|
||||
return "TestPlatform.${this.{core::_Enum::_name}{core::String}}";
|
||||
}
|
||||
static method testAndroid(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testFuchsia(core::int i) → void {
|
||||
final core::bool b = #C2;
|
||||
final core::bool b = #C21;
|
||||
core::print(b);
|
||||
{
|
||||
final core::String os = #C3;
|
||||
final core::String os = #C5;
|
||||
core::print(os);
|
||||
final core::String sep = #C4;
|
||||
final core::String sep = #C22;
|
||||
core::print(sep);
|
||||
}
|
||||
}
|
||||
static method testIOS(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testLinux(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testMacOS(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testWindows(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testSwitchStatements(core::int i) → void {
|
||||
#L1:
|
||||
{
|
||||
core::print("is fuchsia");
|
||||
break #L1;
|
||||
}
|
||||
}
|
||||
@#C25
|
||||
static get defaultTestPlatform() → self::TestPlatform {
|
||||
return #C6;
|
||||
throw "Unexpected platform";
|
||||
}
|
||||
static method testPragma(core::int i) → void {
|
||||
core::print(#C6);
|
||||
#L2:
|
||||
{
|
||||
core::print("is fuchsia");
|
||||
break #L2;
|
||||
}
|
||||
}
|
||||
static method main(core::List<core::String> args) → dynamic {
|
||||
if(args.{core::Iterable::isEmpty}{core::bool})
|
||||
return;
|
||||
|
|
@ -44,10 +78,33 @@ static method main(core::List<core::String> args) → dynamic {
|
|||
self::testLinux(i);
|
||||
self::testMacOS(i);
|
||||
self::testWindows(i);
|
||||
self::testSwitchStatements(i);
|
||||
self::testPragma(i);
|
||||
}
|
||||
constants {
|
||||
#C1 = false
|
||||
#C2 = true
|
||||
#C3 = "fuchsia"
|
||||
#C4 = "/"
|
||||
#C1 = 0
|
||||
#C2 = "android"
|
||||
#C3 = self::TestPlatform {index:#C1, _name:#C2}
|
||||
#C4 = 1
|
||||
#C5 = "fuchsia"
|
||||
#C6 = self::TestPlatform {index:#C4, _name:#C5}
|
||||
#C7 = 2
|
||||
#C8 = "ios"
|
||||
#C9 = self::TestPlatform {index:#C7, _name:#C8}
|
||||
#C10 = 3
|
||||
#C11 = "linux"
|
||||
#C12 = self::TestPlatform {index:#C10, _name:#C11}
|
||||
#C13 = 4
|
||||
#C14 = "macos"
|
||||
#C15 = self::TestPlatform {index:#C13, _name:#C14}
|
||||
#C16 = 5
|
||||
#C17 = "windows"
|
||||
#C18 = self::TestPlatform {index:#C16, _name:#C17}
|
||||
#C19 = <self::TestPlatform>[#C3, #C6, #C9, #C12, #C15, #C18]
|
||||
#C20 = false
|
||||
#C21 = true
|
||||
#C22 = "/"
|
||||
#C23 = "vm:platform-const"
|
||||
#C24 = null
|
||||
#C25 = core::pragma {name:#C23, options:#C24}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,36 +4,70 @@ import "dart:core" as core;
|
|||
|
||||
import "dart:io";
|
||||
|
||||
class TestPlatform extends core::_Enum /*isEnum*/ {
|
||||
static const field core::List<self::TestPlatform> values = #C19;
|
||||
enum-element static const field self::TestPlatform android = #C3;
|
||||
enum-element static const field self::TestPlatform fuchsia = #C6;
|
||||
enum-element static const field self::TestPlatform ios = #C9;
|
||||
enum-element static const field self::TestPlatform linux = #C12;
|
||||
enum-element static const field self::TestPlatform macos = #C15;
|
||||
enum-element static const field self::TestPlatform windows = #C18;
|
||||
const synthetic constructor •(core::int #index, core::String #name) → self::TestPlatform
|
||||
: super core::_Enum::•(#index, #name)
|
||||
;
|
||||
method _enumToString() → core::String
|
||||
return "TestPlatform.${this.{core::_Enum::_name}{core::String}}";
|
||||
}
|
||||
static method testAndroid(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testFuchsia(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testIOS(core::int i) → void {
|
||||
final core::bool b = #C2;
|
||||
final core::bool b = #C21;
|
||||
core::print(b);
|
||||
{
|
||||
final core::String os = #C3;
|
||||
final core::String os = #C8;
|
||||
core::print(os);
|
||||
final core::String sep = #C4;
|
||||
final core::String sep = #C22;
|
||||
core::print(sep);
|
||||
}
|
||||
}
|
||||
static method testLinux(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testMacOS(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testWindows(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testSwitchStatements(core::int i) → void {
|
||||
#L1:
|
||||
{
|
||||
core::print("is ios");
|
||||
break #L1;
|
||||
}
|
||||
}
|
||||
@#C25
|
||||
static get defaultTestPlatform() → self::TestPlatform {
|
||||
return #C9;
|
||||
throw "Unexpected platform";
|
||||
}
|
||||
static method testPragma(core::int i) → void {
|
||||
core::print(#C9);
|
||||
#L2:
|
||||
{
|
||||
core::print("is ios");
|
||||
break #L2;
|
||||
}
|
||||
}
|
||||
static method main(core::List<core::String> args) → dynamic {
|
||||
if(args.{core::Iterable::isEmpty}{core::bool})
|
||||
return;
|
||||
|
|
@ -44,10 +78,33 @@ static method main(core::List<core::String> args) → dynamic {
|
|||
self::testLinux(i);
|
||||
self::testMacOS(i);
|
||||
self::testWindows(i);
|
||||
self::testSwitchStatements(i);
|
||||
self::testPragma(i);
|
||||
}
|
||||
constants {
|
||||
#C1 = false
|
||||
#C2 = true
|
||||
#C3 = "ios"
|
||||
#C4 = "/"
|
||||
#C1 = 0
|
||||
#C2 = "android"
|
||||
#C3 = self::TestPlatform {index:#C1, _name:#C2}
|
||||
#C4 = 1
|
||||
#C5 = "fuchsia"
|
||||
#C6 = self::TestPlatform {index:#C4, _name:#C5}
|
||||
#C7 = 2
|
||||
#C8 = "ios"
|
||||
#C9 = self::TestPlatform {index:#C7, _name:#C8}
|
||||
#C10 = 3
|
||||
#C11 = "linux"
|
||||
#C12 = self::TestPlatform {index:#C10, _name:#C11}
|
||||
#C13 = 4
|
||||
#C14 = "macos"
|
||||
#C15 = self::TestPlatform {index:#C13, _name:#C14}
|
||||
#C16 = 5
|
||||
#C17 = "windows"
|
||||
#C18 = self::TestPlatform {index:#C16, _name:#C17}
|
||||
#C19 = <self::TestPlatform>[#C3, #C6, #C9, #C12, #C15, #C18]
|
||||
#C20 = false
|
||||
#C21 = true
|
||||
#C22 = "/"
|
||||
#C23 = "vm:platform-const"
|
||||
#C24 = null
|
||||
#C25 = core::pragma {name:#C23, options:#C24}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,36 +4,70 @@ import "dart:core" as core;
|
|||
|
||||
import "dart:io";
|
||||
|
||||
class TestPlatform extends core::_Enum /*isEnum*/ {
|
||||
static const field core::List<self::TestPlatform> values = #C19;
|
||||
enum-element static const field self::TestPlatform android = #C3;
|
||||
enum-element static const field self::TestPlatform fuchsia = #C6;
|
||||
enum-element static const field self::TestPlatform ios = #C9;
|
||||
enum-element static const field self::TestPlatform linux = #C12;
|
||||
enum-element static const field self::TestPlatform macos = #C15;
|
||||
enum-element static const field self::TestPlatform windows = #C18;
|
||||
const synthetic constructor •(core::int #index, core::String #name) → self::TestPlatform
|
||||
: super core::_Enum::•(#index, #name)
|
||||
;
|
||||
method _enumToString() → core::String
|
||||
return "TestPlatform.${this.{core::_Enum::_name}{core::String}}";
|
||||
}
|
||||
static method testAndroid(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testFuchsia(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testIOS(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testLinux(core::int i) → void {
|
||||
final core::bool b = #C2;
|
||||
final core::bool b = #C21;
|
||||
core::print(b);
|
||||
{
|
||||
final core::String os = #C3;
|
||||
final core::String os = #C11;
|
||||
core::print(os);
|
||||
final core::String sep = #C4;
|
||||
final core::String sep = #C22;
|
||||
core::print(sep);
|
||||
}
|
||||
}
|
||||
static method testMacOS(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testWindows(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testSwitchStatements(core::int i) → void {
|
||||
#L1:
|
||||
{
|
||||
core::print("is linux");
|
||||
break #L1;
|
||||
}
|
||||
}
|
||||
@#C25
|
||||
static get defaultTestPlatform() → self::TestPlatform {
|
||||
return #C12;
|
||||
throw "Unexpected platform";
|
||||
}
|
||||
static method testPragma(core::int i) → void {
|
||||
core::print(#C12);
|
||||
#L2:
|
||||
{
|
||||
core::print("is linux");
|
||||
break #L2;
|
||||
}
|
||||
}
|
||||
static method main(core::List<core::String> args) → dynamic {
|
||||
if(args.{core::Iterable::isEmpty}{core::bool})
|
||||
return;
|
||||
|
|
@ -44,10 +78,33 @@ static method main(core::List<core::String> args) → dynamic {
|
|||
self::testLinux(i);
|
||||
self::testMacOS(i);
|
||||
self::testWindows(i);
|
||||
self::testSwitchStatements(i);
|
||||
self::testPragma(i);
|
||||
}
|
||||
constants {
|
||||
#C1 = false
|
||||
#C2 = true
|
||||
#C3 = "linux"
|
||||
#C4 = "/"
|
||||
#C1 = 0
|
||||
#C2 = "android"
|
||||
#C3 = self::TestPlatform {index:#C1, _name:#C2}
|
||||
#C4 = 1
|
||||
#C5 = "fuchsia"
|
||||
#C6 = self::TestPlatform {index:#C4, _name:#C5}
|
||||
#C7 = 2
|
||||
#C8 = "ios"
|
||||
#C9 = self::TestPlatform {index:#C7, _name:#C8}
|
||||
#C10 = 3
|
||||
#C11 = "linux"
|
||||
#C12 = self::TestPlatform {index:#C10, _name:#C11}
|
||||
#C13 = 4
|
||||
#C14 = "macos"
|
||||
#C15 = self::TestPlatform {index:#C13, _name:#C14}
|
||||
#C16 = 5
|
||||
#C17 = "windows"
|
||||
#C18 = self::TestPlatform {index:#C16, _name:#C17}
|
||||
#C19 = <self::TestPlatform>[#C3, #C6, #C9, #C12, #C15, #C18]
|
||||
#C20 = false
|
||||
#C21 = true
|
||||
#C22 = "/"
|
||||
#C23 = "vm:platform-const"
|
||||
#C24 = null
|
||||
#C25 = core::pragma {name:#C23, options:#C24}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,36 +4,70 @@ import "dart:core" as core;
|
|||
|
||||
import "dart:io";
|
||||
|
||||
class TestPlatform extends core::_Enum /*isEnum*/ {
|
||||
static const field core::List<self::TestPlatform> values = #C19;
|
||||
enum-element static const field self::TestPlatform android = #C3;
|
||||
enum-element static const field self::TestPlatform fuchsia = #C6;
|
||||
enum-element static const field self::TestPlatform ios = #C9;
|
||||
enum-element static const field self::TestPlatform linux = #C12;
|
||||
enum-element static const field self::TestPlatform macos = #C15;
|
||||
enum-element static const field self::TestPlatform windows = #C18;
|
||||
const synthetic constructor •(core::int #index, core::String #name) → self::TestPlatform
|
||||
: super core::_Enum::•(#index, #name)
|
||||
;
|
||||
method _enumToString() → core::String
|
||||
return "TestPlatform.${this.{core::_Enum::_name}{core::String}}";
|
||||
}
|
||||
static method testAndroid(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testFuchsia(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testIOS(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testLinux(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testMacOS(core::int i) → void {
|
||||
final core::bool b = #C2;
|
||||
final core::bool b = #C21;
|
||||
core::print(b);
|
||||
{
|
||||
final core::String os = #C3;
|
||||
final core::String os = #C14;
|
||||
core::print(os);
|
||||
final core::String sep = #C4;
|
||||
final core::String sep = #C22;
|
||||
core::print(sep);
|
||||
}
|
||||
}
|
||||
static method testWindows(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testSwitchStatements(core::int i) → void {
|
||||
#L1:
|
||||
{
|
||||
core::print("is macos");
|
||||
break #L1;
|
||||
}
|
||||
}
|
||||
@#C25
|
||||
static get defaultTestPlatform() → self::TestPlatform {
|
||||
return #C15;
|
||||
throw "Unexpected platform";
|
||||
}
|
||||
static method testPragma(core::int i) → void {
|
||||
core::print(#C15);
|
||||
#L2:
|
||||
{
|
||||
core::print("is macos");
|
||||
break #L2;
|
||||
}
|
||||
}
|
||||
static method main(core::List<core::String> args) → dynamic {
|
||||
if(args.{core::Iterable::isEmpty}{core::bool})
|
||||
return;
|
||||
|
|
@ -44,10 +78,33 @@ static method main(core::List<core::String> args) → dynamic {
|
|||
self::testLinux(i);
|
||||
self::testMacOS(i);
|
||||
self::testWindows(i);
|
||||
self::testSwitchStatements(i);
|
||||
self::testPragma(i);
|
||||
}
|
||||
constants {
|
||||
#C1 = false
|
||||
#C2 = true
|
||||
#C3 = "macos"
|
||||
#C4 = "/"
|
||||
#C1 = 0
|
||||
#C2 = "android"
|
||||
#C3 = self::TestPlatform {index:#C1, _name:#C2}
|
||||
#C4 = 1
|
||||
#C5 = "fuchsia"
|
||||
#C6 = self::TestPlatform {index:#C4, _name:#C5}
|
||||
#C7 = 2
|
||||
#C8 = "ios"
|
||||
#C9 = self::TestPlatform {index:#C7, _name:#C8}
|
||||
#C10 = 3
|
||||
#C11 = "linux"
|
||||
#C12 = self::TestPlatform {index:#C10, _name:#C11}
|
||||
#C13 = 4
|
||||
#C14 = "macos"
|
||||
#C15 = self::TestPlatform {index:#C13, _name:#C14}
|
||||
#C16 = 5
|
||||
#C17 = "windows"
|
||||
#C18 = self::TestPlatform {index:#C16, _name:#C17}
|
||||
#C19 = <self::TestPlatform>[#C3, #C6, #C9, #C12, #C15, #C18]
|
||||
#C20 = false
|
||||
#C21 = true
|
||||
#C22 = "/"
|
||||
#C23 = "vm:platform-const"
|
||||
#C24 = null
|
||||
#C25 = core::pragma {name:#C23, options:#C24}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,36 +4,70 @@ import "dart:core" as core;
|
|||
|
||||
import "dart:io";
|
||||
|
||||
class TestPlatform extends core::_Enum /*isEnum*/ {
|
||||
static const field core::List<self::TestPlatform> values = #C19;
|
||||
enum-element static const field self::TestPlatform android = #C3;
|
||||
enum-element static const field self::TestPlatform fuchsia = #C6;
|
||||
enum-element static const field self::TestPlatform ios = #C9;
|
||||
enum-element static const field self::TestPlatform linux = #C12;
|
||||
enum-element static const field self::TestPlatform macos = #C15;
|
||||
enum-element static const field self::TestPlatform windows = #C18;
|
||||
const synthetic constructor •(core::int #index, core::String #name) → self::TestPlatform
|
||||
: super core::_Enum::•(#index, #name)
|
||||
;
|
||||
method _enumToString() → core::String
|
||||
return "TestPlatform.${this.{core::_Enum::_name}{core::String}}";
|
||||
}
|
||||
static method testAndroid(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testFuchsia(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testIOS(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testLinux(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testMacOS(core::int i) → void {
|
||||
final core::bool b = #C1;
|
||||
final core::bool b = #C20;
|
||||
core::print(b);
|
||||
}
|
||||
static method testWindows(core::int i) → void {
|
||||
final core::bool b = #C2;
|
||||
final core::bool b = #C21;
|
||||
core::print(b);
|
||||
{
|
||||
final core::String os = #C3;
|
||||
final core::String os = #C17;
|
||||
core::print(os);
|
||||
final core::String sep = #C4;
|
||||
final core::String sep = #C22;
|
||||
core::print(sep);
|
||||
}
|
||||
}
|
||||
static method testSwitchStatements(core::int i) → void {
|
||||
#L1:
|
||||
{
|
||||
core::print("is windows");
|
||||
break #L1;
|
||||
}
|
||||
}
|
||||
@#C25
|
||||
static get defaultTestPlatform() → self::TestPlatform {
|
||||
return #C18;
|
||||
throw "Unexpected platform";
|
||||
}
|
||||
static method testPragma(core::int i) → void {
|
||||
core::print(#C18);
|
||||
#L2:
|
||||
{
|
||||
core::print("is windows");
|
||||
break #L2;
|
||||
}
|
||||
}
|
||||
static method main(core::List<core::String> args) → dynamic {
|
||||
if(args.{core::Iterable::isEmpty}{core::bool})
|
||||
return;
|
||||
|
|
@ -44,10 +78,33 @@ static method main(core::List<core::String> args) → dynamic {
|
|||
self::testLinux(i);
|
||||
self::testMacOS(i);
|
||||
self::testWindows(i);
|
||||
self::testSwitchStatements(i);
|
||||
self::testPragma(i);
|
||||
}
|
||||
constants {
|
||||
#C1 = false
|
||||
#C2 = true
|
||||
#C3 = "windows"
|
||||
#C4 = "\\"
|
||||
#C1 = 0
|
||||
#C2 = "android"
|
||||
#C3 = self::TestPlatform {index:#C1, _name:#C2}
|
||||
#C4 = 1
|
||||
#C5 = "fuchsia"
|
||||
#C6 = self::TestPlatform {index:#C4, _name:#C5}
|
||||
#C7 = 2
|
||||
#C8 = "ios"
|
||||
#C9 = self::TestPlatform {index:#C7, _name:#C8}
|
||||
#C10 = 3
|
||||
#C11 = "linux"
|
||||
#C12 = self::TestPlatform {index:#C10, _name:#C11}
|
||||
#C13 = 4
|
||||
#C14 = "macos"
|
||||
#C15 = self::TestPlatform {index:#C13, _name:#C14}
|
||||
#C16 = 5
|
||||
#C17 = "windows"
|
||||
#C18 = self::TestPlatform {index:#C16, _name:#C17}
|
||||
#C19 = <self::TestPlatform>[#C3, #C6, #C9, #C12, #C15, #C18]
|
||||
#C20 = false
|
||||
#C21 = true
|
||||
#C22 = "\\"
|
||||
#C23 = "vm:platform-const"
|
||||
#C24 = null
|
||||
#C25 = core::pragma {name:#C23, options:#C24}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue