mirror of
https://github.com/dart-lang/sdk
synced 2024-09-16 02:57:35 +00:00
fix #620, infer the input files from sources
also simplifies build of packages used by our tests this caused a bunch of tests that use parts to start passing R=nweiz@google.com Review URL: https://codereview.chromium.org/2234343003 .
This commit is contained in:
John Messerly
parent
3d43b1df5b
commit
0aa5cbd128
|
|
@ -15,13 +15,7 @@ module.exports = function(config) {
|
|||
files: [
|
||||
'lib/runtime/dart_*.js',
|
||||
// {pattern: 'test/browser/*.js', included: false}
|
||||
'gen/codegen_output/async_helper/async_helper.js',
|
||||
'gen/codegen_output/expect/expect.js',
|
||||
'gen/codegen_output/path/path.js',
|
||||
'gen/codegen_output/stack_trace/stack_trace.js',
|
||||
'gen/codegen_output/js/js.js',
|
||||
'gen/codegen_output/matcher/matcher.js',
|
||||
'gen/codegen_output/unittest/unittest.js',
|
||||
'gen/codegen_output/pkg/*.js',
|
||||
'gen/codegen_output/language/**.js',
|
||||
'gen/codegen_output/language/**.err',
|
||||
'gen/codegen_output/corelib/**.js',
|
||||
|
|
|
|||
|
|
@ -236,7 +236,7 @@ class CodeGenerator extends GeneralizingAstVisitor
|
|||
items.add(new JS.ExportDeclaration(
|
||||
js.call('const # = Object.create(null)', [libraryTemp])));
|
||||
|
||||
// dart:_runtime has a magic module that holds extenstion method symbols.
|
||||
// dart:_runtime has a magic module that holds extension method symbols.
|
||||
// TODO(jmesserly): find a cleaner design for this.
|
||||
if (_isDartRuntime(library)) {
|
||||
items.add(new JS.ExportDeclaration(
|
||||
|
|
|
|||
|
|
@ -2,21 +2,19 @@
|
|||
// for details. All rights reserved. Use of this source code is governed by a
|
||||
// BSD-style license that can be found in the LICENSE file.
|
||||
|
||||
import 'dart:collection' show HashSet;
|
||||
import 'package:args/args.dart' show ArgParser, ArgResults;
|
||||
import 'package:args/src/usage_exception.dart' show UsageException;
|
||||
import 'dart:collection' show HashSet, Queue;
|
||||
import 'package:analyzer/dart/element/element.dart' show LibraryElement;
|
||||
import 'package:analyzer/analyzer.dart'
|
||||
show
|
||||
AnalysisError,
|
||||
CompilationUnit,
|
||||
CompileTimeErrorCode,
|
||||
ErrorSeverity,
|
||||
StaticWarningCode;
|
||||
show AnalysisError, CompilationUnit, ErrorSeverity;
|
||||
import 'package:analyzer/file_system/file_system.dart' show ResourceProvider;
|
||||
import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
|
||||
import 'package:analyzer/src/generated/source.dart' show DartUriResolver;
|
||||
import 'package:analyzer/src/generated/source_io.dart'
|
||||
show Source, SourceKind, UriResolver;
|
||||
import 'package:analyzer/src/summary/package_bundle_reader.dart'
|
||||
show InSummarySource;
|
||||
import 'package:args/args.dart' show ArgParser, ArgResults;
|
||||
import 'package:args/src/usage_exception.dart' show UsageException;
|
||||
import 'package:func/func.dart' show Func1;
|
||||
import 'package:path/path.dart' as path;
|
||||
|
||||
|
|
@ -76,14 +74,15 @@ class ModuleCompiler {
|
|||
var trees = <CompilationUnit>[];
|
||||
var errors = <AnalysisError>[];
|
||||
|
||||
// Validate that all parts were explicitly passed in.
|
||||
// If not, it's an error.
|
||||
var explicitParts = new HashSet<Source>();
|
||||
var usedParts = new HashSet<Source>();
|
||||
var librariesToCompile = new Queue<LibraryElement>();
|
||||
|
||||
var compilingSdk = false;
|
||||
for (var sourcePath in unit.sources) {
|
||||
var sourceUri = Uri.parse(sourcePath);
|
||||
if (sourceUri.scheme == '') {
|
||||
sourceUri = path.toUri(path.absolute(sourcePath));
|
||||
} else if (sourceUri.scheme == 'dart') {
|
||||
compilingSdk = true;
|
||||
}
|
||||
Source source = context.sourceFactory.forUri2(sourceUri);
|
||||
|
||||
|
|
@ -101,31 +100,32 @@ class ModuleCompiler {
|
|||
|
||||
// Ignore parts. They need to be handled in the context of their library.
|
||||
if (context.computeKindOf(source) == SourceKind.PART) {
|
||||
explicitParts.add(source);
|
||||
continue;
|
||||
}
|
||||
|
||||
var resolvedTree = context.resolveCompilationUnit2(source, source);
|
||||
trees.add(resolvedTree);
|
||||
errors.addAll(context.computeErrors(source));
|
||||
librariesToCompile.add(context.computeLibraryElement(source));
|
||||
}
|
||||
|
||||
var libraries = new HashSet<LibraryElement>();
|
||||
while (librariesToCompile.isNotEmpty) {
|
||||
var library = librariesToCompile.removeFirst();
|
||||
if (library.source is InSummarySource) continue;
|
||||
if (!compilingSdk && library.source.isInSystemLibrary) continue;
|
||||
if (!libraries.add(library)) continue;
|
||||
|
||||
librariesToCompile.addAll(library.importedLibraries);
|
||||
librariesToCompile.addAll(library.exportedLibraries);
|
||||
|
||||
var tree = context.resolveCompilationUnit(library.source, library);
|
||||
trees.add(tree);
|
||||
errors.addAll(context.computeErrors(library.source));
|
||||
|
||||
var library = resolvedTree.element.library;
|
||||
for (var part in library.parts) {
|
||||
if (!library.isInSdk) usedParts.add(part.source);
|
||||
trees.add(context.resolveCompilationUnit(part.source, library));
|
||||
errors.addAll(context.computeErrors(part.source));
|
||||
}
|
||||
}
|
||||
|
||||
// Check if all parts were explicitly passed in.
|
||||
// Also verify all explicitly parts were used.
|
||||
var missingParts = usedParts.difference(explicitParts);
|
||||
var unusedParts = explicitParts.difference(usedParts);
|
||||
errors.addAll(missingParts
|
||||
.map((s) => new AnalysisError(s, 0, 0, missingPartErrorCode)));
|
||||
errors.addAll(unusedParts
|
||||
.map((s) => new AnalysisError(s, 0, 0, unusedPartWarningCode)));
|
||||
|
||||
sortErrors(context, errors);
|
||||
var messages = <String>[];
|
||||
for (var e in errors) {
|
||||
|
|
@ -365,11 +365,3 @@ class JSModuleFile {
|
|||
return map;
|
||||
}
|
||||
}
|
||||
|
||||
/// (Public for tests) the error code used when a part is missing.
|
||||
final missingPartErrorCode = const CompileTimeErrorCode(
|
||||
'MISSING_PART', 'The part was not supplied as an input to the compiler.');
|
||||
|
||||
/// (Public for tests) the error code used when a part is unused.
|
||||
final unusedPartWarningCode = const StaticWarningCode('UNUSED_PART',
|
||||
'The part was not used by any libraries being compiled.', null, false);
|
||||
|
|
|
|||
|
|
@ -319,4 +319,5 @@ packages:
|
|||
url: "https://pub.dartlang.org"
|
||||
source: hosted
|
||||
version: "2.1.10"
|
||||
sdk: ">=1.17.0-dev.6.2 <2.0.0"
|
||||
sdks:
|
||||
dart: ">=1.17.0-dev.6.2 <2.0.0"
|
||||
|
|
|
|||
|
|
@ -202,6 +202,7 @@
|
|||
'generic_field_mixin4_test': skip_fail,
|
||||
'generic_field_mixin5_test': skip_fail,
|
||||
'generic_field_mixin_test': skip_fail,
|
||||
'generic_instanceof_test': fail, // runtime strong mode reject
|
||||
'generic_instanceof2_test': skip_fail,
|
||||
'generic_is_check_test': skip_fail,
|
||||
'getter_closure_execution_order_test': skip_fail,
|
||||
|
|
@ -338,7 +339,6 @@
|
|||
'abstract_runtime_error_test_03_multi': notyetstrong,
|
||||
'abstract_syntax_test_00_multi': notyetstrong,
|
||||
'abstract_syntax_test_01_multi': notyetstrong,
|
||||
'application_test': notyetstrong,
|
||||
'argument_definition_test_01_multi': notyetstrong,
|
||||
'arithmetic_test': notyetstrong,
|
||||
'assign_static_type_test_01_multi': notyetstrong,
|
||||
|
|
@ -937,9 +937,6 @@
|
|||
'enum_syntax_test_30_multi': notyetstrong,
|
||||
'error_stacktrace_test': notyetstrong,
|
||||
'example_constructor_test': notyetstrong,
|
||||
'export_double_same_main_test': notyetstrong,
|
||||
'export_main_override_test': notyetstrong,
|
||||
'export_main_test': notyetstrong,
|
||||
'external_test_01_multi': notyetstrong,
|
||||
'external_test_02_multi': notyetstrong,
|
||||
'external_test_11_multi': notyetstrong,
|
||||
|
|
@ -1118,7 +1115,6 @@
|
|||
'generic_constructor_mixin_test': notyetstrong,
|
||||
'generic_field_mixin6_test_01_multi': notyetstrong,
|
||||
'generic_field_mixin6_test_none_multi': notyetstrong,
|
||||
'generic_instanceof_test': notyetstrong,
|
||||
'generic_list_checked_test': notyetstrong,
|
||||
'generic_test': notyetstrong,
|
||||
'generics_test': notyetstrong,
|
||||
|
|
@ -1157,7 +1153,6 @@
|
|||
'getter_setter_in_lib_test': notyetstrong,
|
||||
'getters_setters2_test_02_multi': notyetstrong,
|
||||
'getters_setters2_test_03_multi': notyetstrong,
|
||||
'hello_script_test': notyetstrong,
|
||||
'hidden_import_test_01_multi': notyetstrong,
|
||||
'hidden_import_test_02_multi': notyetstrong,
|
||||
'identical_const_test_01_multi': notyetstrong,
|
||||
|
|
@ -1239,7 +1234,6 @@
|
|||
'inferrer_this_access_test': notyetstrong,
|
||||
'inline_effect_context_test': notyetstrong,
|
||||
'inline_in_for_initializer_and_bailout_test': notyetstrong,
|
||||
'inline_super_test': notyetstrong,
|
||||
'inline_test_context_test': notyetstrong,
|
||||
'inline_value_context_test': notyetstrong,
|
||||
'inlined_throw_test': notyetstrong,
|
||||
|
|
@ -1281,7 +1275,6 @@
|
|||
'keyword_type_expression_test_02_multi': notyetstrong,
|
||||
'keyword_type_expression_test_03_multi': notyetstrong,
|
||||
'label_test': notyetstrong,
|
||||
'lazy_static6_test': notyetstrong,
|
||||
'least_upper_bound_expansive_test_01_multi': notyetstrong,
|
||||
'least_upper_bound_expansive_test_02_multi': notyetstrong,
|
||||
'least_upper_bound_expansive_test_03_multi': notyetstrong,
|
||||
|
|
@ -1305,15 +1298,12 @@
|
|||
'least_upper_bound_test_29_multi': notyetstrong,
|
||||
'least_upper_bound_test_30_multi': notyetstrong,
|
||||
'least_upper_bound_test_32_multi': notyetstrong,
|
||||
'library1_test': notyetstrong,
|
||||
'library_ambiguous_test_00_multi': notyetstrong,
|
||||
'library_ambiguous_test_01_multi': notyetstrong,
|
||||
'library_ambiguous_test_02_multi': notyetstrong,
|
||||
'library_ambiguous_test_03_multi': notyetstrong,
|
||||
'library_ambiguous_test_04_multi': notyetstrong,
|
||||
'library_ambiguous_test_05_multi': notyetstrong,
|
||||
'library_juxtaposition_test': notyetstrong,
|
||||
'library_prefixes_test': notyetstrong,
|
||||
'list_double_index_in_loop2_test': notyetstrong,
|
||||
'list_double_index_in_loop_test': notyetstrong,
|
||||
'list_literal1_test_01_multi': notyetstrong,
|
||||
|
|
@ -1565,8 +1555,6 @@
|
|||
'mixin_type_parameters_super_extends_test': notyetstrong,
|
||||
'mixin_type_parameters_super_test': notyetstrong,
|
||||
'mixin_with_two_implicit_constructors_test': notyetstrong,
|
||||
'multi_pass2_test': notyetstrong,
|
||||
'multi_pass_test': notyetstrong,
|
||||
'multiline_newline_test_01_multi': notyetstrong,
|
||||
'multiline_newline_test_02_multi': notyetstrong,
|
||||
'multiline_newline_test_03_multi': notyetstrong,
|
||||
|
|
@ -1754,7 +1742,6 @@
|
|||
'parameter_initializer_test': notyetstrong,
|
||||
'parser_quirks_test': notyetstrong,
|
||||
'part2_test': notyetstrong,
|
||||
'part_test': notyetstrong,
|
||||
'positional_parameters_type_test_01_multi': notyetstrong,
|
||||
'positional_parameters_type_test_02_multi': notyetstrong,
|
||||
'prefix14_test': notyetstrong,
|
||||
|
|
@ -1771,7 +1758,6 @@
|
|||
'prefix_identifier_reference_test_05_multi': notyetstrong,
|
||||
'prefix_unqualified_invocation_test_01_multi': notyetstrong,
|
||||
'prefix_unqualified_invocation_test_02_multi': notyetstrong,
|
||||
'private2_test': notyetstrong,
|
||||
'private3_test': notyetstrong,
|
||||
'private_access_test_01_multi': notyetstrong,
|
||||
'private_access_test_02_multi': notyetstrong,
|
||||
|
|
@ -2051,10 +2037,8 @@
|
|||
'this_test_07_multi': notyetstrong,
|
||||
'this_test_08_multi': notyetstrong,
|
||||
'throw_expr_test': notyetstrong,
|
||||
'top_level_entry_test': notyetstrong,
|
||||
'top_level_getter_no_setter1_test_01_multi': notyetstrong,
|
||||
'top_level_getter_no_setter2_test_01_multi': notyetstrong,
|
||||
'top_level_multiple_files_test': notyetstrong,
|
||||
'toplevel_collision1_test_00_multi': notyetstrong,
|
||||
'toplevel_collision1_test_01_multi': notyetstrong,
|
||||
'toplevel_collision1_test_02_multi': notyetstrong,
|
||||
|
|
@ -2496,7 +2480,7 @@
|
|||
'package_resource_test': notyetstrong,
|
||||
'print_test_01_multi': notyetstrong,
|
||||
'print_test_none_multi': notyetstrong,
|
||||
'set_test': notyetstrong,
|
||||
'set_test': fail, // runtime strong mode reject
|
||||
'splay_tree_test': notyetstrong,
|
||||
'string_base_vm_test': notyetstrong,
|
||||
'string_from_environment3_test_01_multi': notyetstrong,
|
||||
|
|
|
|||
|
|
@ -1,76 +0,0 @@
|
|||
dart_library.library('async_helper', null, /* Imports */[
|
||||
'dart_sdk'
|
||||
], function load__async_helper(exports, dart_sdk) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const async_helper = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.functionType(dart.dynamic, [])))();
|
||||
let StringToException = () => (StringToException = dart.constFn(dart.definiteFunctionType(core.Exception, [core.String])))();
|
||||
let _Action0Tovoid = () => (_Action0Tovoid = dart.constFn(dart.definiteFunctionType(dart.void, [async_helper._Action0])))();
|
||||
let VoidTovoid = () => (VoidTovoid = dart.constFn(dart.definiteFunctionType(dart.void, [])))();
|
||||
let dynamicTovoid = () => (dynamicTovoid = dart.constFn(dart.definiteFunctionType(dart.void, [dart.dynamic])))();
|
||||
let FnTovoid = () => (FnTovoid = dart.constFn(dart.definiteFunctionType(dart.void, [VoidTodynamic()])))();
|
||||
async_helper._initialized = false;
|
||||
async_helper._Action0 = dart.typedef('_Action0', () => dart.functionType(dart.void, []));
|
||||
async_helper._onAsyncEnd = null;
|
||||
async_helper._asyncLevel = 0;
|
||||
async_helper._buildException = function(msg) {
|
||||
return core.Exception.new(dart.str`Fatal: ${msg}. This is most likely a bug in your test.`);
|
||||
};
|
||||
dart.fn(async_helper._buildException, StringToException());
|
||||
async_helper.asyncTestInitialize = function(callback) {
|
||||
async_helper._asyncLevel = 0;
|
||||
async_helper._initialized = false;
|
||||
async_helper._onAsyncEnd = callback;
|
||||
};
|
||||
dart.fn(async_helper.asyncTestInitialize, _Action0Tovoid());
|
||||
dart.copyProperties(async_helper, {
|
||||
get asyncTestStarted() {
|
||||
return async_helper._initialized;
|
||||
}
|
||||
});
|
||||
async_helper.asyncStart = function() {
|
||||
if (dart.test(async_helper._initialized) && async_helper._asyncLevel == 0) {
|
||||
dart.throw(async_helper._buildException('asyncStart() was called even though we are done ' + 'with testing.'));
|
||||
}
|
||||
if (!dart.test(async_helper._initialized)) {
|
||||
if (async_helper._onAsyncEnd == null) {
|
||||
dart.throw(async_helper._buildException('asyncStart() was called before asyncTestInitialize()'));
|
||||
}
|
||||
core.print('unittest-suite-wait-for-done');
|
||||
async_helper._initialized = true;
|
||||
}
|
||||
async_helper._asyncLevel = dart.notNull(async_helper._asyncLevel) + 1;
|
||||
};
|
||||
dart.fn(async_helper.asyncStart, VoidTovoid());
|
||||
async_helper.asyncEnd = function() {
|
||||
if (dart.notNull(async_helper._asyncLevel) <= 0) {
|
||||
if (!dart.test(async_helper._initialized)) {
|
||||
dart.throw(async_helper._buildException('asyncEnd() was called before asyncStart().'));
|
||||
} else {
|
||||
dart.throw(async_helper._buildException('asyncEnd() was called more often than ' + 'asyncStart().'));
|
||||
}
|
||||
}
|
||||
async_helper._asyncLevel = dart.notNull(async_helper._asyncLevel) - 1;
|
||||
if (async_helper._asyncLevel == 0) {
|
||||
let callback = async_helper._onAsyncEnd;
|
||||
async_helper._onAsyncEnd = null;
|
||||
callback();
|
||||
core.print('unittest-suite-success');
|
||||
}
|
||||
};
|
||||
dart.fn(async_helper.asyncEnd, VoidTovoid());
|
||||
async_helper.asyncSuccess = function(_) {
|
||||
return async_helper.asyncEnd();
|
||||
};
|
||||
dart.fn(async_helper.asyncSuccess, dynamicTovoid());
|
||||
async_helper.asyncTest = function(f) {
|
||||
async_helper.asyncStart();
|
||||
dart.dsend(f(), 'then', async_helper.asyncSuccess);
|
||||
};
|
||||
dart.fn(async_helper.asyncTest, FnTovoid());
|
||||
// Exports:
|
||||
exports.async_helper = async_helper;
|
||||
});
|
||||
|
|
@ -6,6 +6,7 @@ dart_library.library('destructuring', null, /* Imports */[
|
|||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const destructuring = Object.create(null);
|
||||
const src__varargs = Object.create(null);
|
||||
let intAnddynamic__Todynamic = () => (intAnddynamic__Todynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [core.int, dart.dynamic], [dart.dynamic])))();
|
||||
let intAnddynamic__Todynamic$ = () => (intAnddynamic__Todynamic$ = dart.constFn(dart.definiteFunctionType(dart.dynamic, [core.int, dart.dynamic], {c: dart.dynamic})))();
|
||||
let intAnddynamicTodynamic = () => (intAnddynamicTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [core.int, dart.dynamic])))();
|
||||
|
|
@ -13,6 +14,7 @@ dart_library.library('destructuring', null, /* Imports */[
|
|||
let __Todynamic = () => (__Todynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [], [core.int, dart.dynamic, dart.dynamic])))();
|
||||
let __Todynamic$ = () => (__Todynamic$ = dart.constFn(dart.definiteFunctionType(dart.dynamic, [], {let: core.int, function: dart.dynamic, arguments: dart.dynamic})))();
|
||||
let __Todynamic$0 = () => (__Todynamic$0 = dart.constFn(dart.definiteFunctionType(dart.dynamic, [], {constructor: core.int, valueOf: dart.dynamic, hasOwnProperty: dart.dynamic})))();
|
||||
let dynamicTodynamic = () => (dynamicTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [dart.dynamic])))();
|
||||
destructuring.f = function(a, b, c = 1) {
|
||||
destructuring.f(a, b, c);
|
||||
};
|
||||
|
|
@ -71,6 +73,19 @@ dart_library.library('destructuring', null, /* Imports */[
|
|||
destructuring.f(constructor, valueOf, hasOwnProperty);
|
||||
};
|
||||
dart.fn(destructuring.names_clashing_with_object_props, __Todynamic$0());
|
||||
src__varargs._Rest = class _Rest extends core.Object {
|
||||
new() {
|
||||
}
|
||||
};
|
||||
dart.setSignature(src__varargs._Rest, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(src__varargs._Rest, [])})
|
||||
});
|
||||
src__varargs.rest = dart.const(new src__varargs._Rest());
|
||||
src__varargs.spread = function(args) {
|
||||
dart.throw(new core.StateError('The spread function cannot be called, ' + 'it should be compiled away.'));
|
||||
};
|
||||
dart.fn(src__varargs.spread, dynamicTodynamic());
|
||||
// Exports:
|
||||
exports.destructuring = destructuring;
|
||||
exports.src__varargs = src__varargs;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,304 +0,0 @@
|
|||
dart_library.library('expect', null, /* Imports */[
|
||||
'dart_sdk'
|
||||
], function load__expect(exports, dart_sdk) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect = Object.create(null);
|
||||
let dynamicAnddynamicTobool = () => (dynamicAnddynamicTobool = dart.constFn(dart.definiteFunctionType(core.bool, [dart.dynamic, dart.dynamic])))();
|
||||
expect.Expect = class Expect extends core.Object {
|
||||
static _truncateString(string, start, end, length) {
|
||||
if (dart.notNull(end) - dart.notNull(start) > dart.notNull(length)) {
|
||||
end = dart.notNull(start) + dart.notNull(length);
|
||||
} else if (dart.notNull(end) - dart.notNull(start) < dart.notNull(length)) {
|
||||
let overflow = dart.notNull(length) - (dart.notNull(end) - dart.notNull(start));
|
||||
if (overflow > 10) overflow = 10;
|
||||
start = dart.notNull(start) - ((overflow + 1) / 2)[dartx.truncate]();
|
||||
end = dart.notNull(end) + (overflow / 2)[dartx.truncate]();
|
||||
if (dart.notNull(start) < 0) start = 0;
|
||||
if (dart.notNull(end) > dart.notNull(string[dartx.length])) end = string[dartx.length];
|
||||
}
|
||||
if (start == 0 && end == string[dartx.length]) return string;
|
||||
let buf = new core.StringBuffer();
|
||||
if (dart.notNull(start) > 0) buf.write("...");
|
||||
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
|
||||
let code = string[dartx.codeUnitAt](i);
|
||||
if (dart.notNull(code) < 32) {
|
||||
buf.write("\\x");
|
||||
buf.write("0123456789abcdef"[dartx.get]((dart.notNull(code) / 16)[dartx.truncate]()));
|
||||
buf.write("0123456789abcdef"[dartx.get](code[dartx['%']](16)));
|
||||
} else {
|
||||
buf.writeCharCode(string[dartx.codeUnitAt](i));
|
||||
}
|
||||
}
|
||||
if (dart.notNull(end) < dart.notNull(string[dartx.length])) buf.write("...");
|
||||
return buf.toString();
|
||||
}
|
||||
static _stringDifference(expected, actual) {
|
||||
if (dart.notNull(expected[dartx.length]) < 20 && dart.notNull(actual[dartx.length]) < 20) return null;
|
||||
for (let i = 0; i < dart.notNull(expected[dartx.length]) && i < dart.notNull(actual[dartx.length]); i++) {
|
||||
if (expected[dartx.codeUnitAt](i) != actual[dartx.codeUnitAt](i)) {
|
||||
let start = i;
|
||||
i++;
|
||||
while (i < dart.notNull(expected[dartx.length]) && i < dart.notNull(actual[dartx.length])) {
|
||||
if (expected[dartx.codeUnitAt](i) == actual[dartx.codeUnitAt](i)) break;
|
||||
i++;
|
||||
}
|
||||
let end = i;
|
||||
let truncExpected = expect.Expect._truncateString(expected, start, end, 20);
|
||||
let truncActual = expect.Expect._truncateString(actual, start, end, 20);
|
||||
return dart.str`at index ${start}: Expected <${truncExpected}>, ` + dart.str`Found: <${truncActual}>`;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
static equals(expected, actual, reason) {
|
||||
if (reason === void 0) reason = null;
|
||||
if (dart.equals(expected, actual)) return;
|
||||
let msg = expect.Expect._getMessage(reason);
|
||||
if (typeof expected == 'string' && typeof actual == 'string') {
|
||||
let stringDifference = expect.Expect._stringDifference(expected, actual);
|
||||
if (stringDifference != null) {
|
||||
expect.Expect._fail(dart.str`Expect.equals(${stringDifference}${msg}) fails.`);
|
||||
}
|
||||
}
|
||||
expect.Expect._fail(dart.str`Expect.equals(expected: <${expected}>, actual: <${actual}>${msg}) fails.`);
|
||||
}
|
||||
static isTrue(actual, reason) {
|
||||
if (reason === void 0) reason = null;
|
||||
if (dart.test(expect._identical(actual, true))) return;
|
||||
let msg = expect.Expect._getMessage(reason);
|
||||
expect.Expect._fail(dart.str`Expect.isTrue(${actual}${msg}) fails.`);
|
||||
}
|
||||
static isFalse(actual, reason) {
|
||||
if (reason === void 0) reason = null;
|
||||
if (dart.test(expect._identical(actual, false))) return;
|
||||
let msg = expect.Expect._getMessage(reason);
|
||||
expect.Expect._fail(dart.str`Expect.isFalse(${actual}${msg}) fails.`);
|
||||
}
|
||||
static isNull(actual, reason) {
|
||||
if (reason === void 0) reason = null;
|
||||
if (null == actual) return;
|
||||
let msg = expect.Expect._getMessage(reason);
|
||||
expect.Expect._fail(dart.str`Expect.isNull(actual: <${actual}>${msg}) fails.`);
|
||||
}
|
||||
static isNotNull(actual, reason) {
|
||||
if (reason === void 0) reason = null;
|
||||
if (null != actual) return;
|
||||
let msg = expect.Expect._getMessage(reason);
|
||||
expect.Expect._fail(dart.str`Expect.isNotNull(actual: <${actual}>${msg}) fails.`);
|
||||
}
|
||||
static identical(expected, actual, reason) {
|
||||
if (reason === void 0) reason = null;
|
||||
if (dart.test(expect._identical(expected, actual))) return;
|
||||
let msg = expect.Expect._getMessage(reason);
|
||||
expect.Expect._fail(dart.str`Expect.identical(expected: <${expected}>, actual: <${actual}>${msg}) ` + "fails.");
|
||||
}
|
||||
static fail(msg) {
|
||||
expect.Expect._fail(dart.str`Expect.fail('${msg}')`);
|
||||
}
|
||||
static approxEquals(expected, actual, tolerance, reason) {
|
||||
if (tolerance === void 0) tolerance = null;
|
||||
if (reason === void 0) reason = null;
|
||||
if (tolerance == null) {
|
||||
tolerance = (dart.notNull(expected) / 10000.0)[dartx.abs]();
|
||||
}
|
||||
if (dart.notNull((dart.notNull(expected) - dart.notNull(actual))[dartx.abs]()) <= dart.notNull(tolerance)) return;
|
||||
let msg = expect.Expect._getMessage(reason);
|
||||
expect.Expect._fail(dart.str`Expect.approxEquals(expected:<${expected}>, actual:<${actual}>, ` + dart.str`tolerance:<${tolerance}>${msg}) fails`);
|
||||
}
|
||||
static notEquals(unexpected, actual, reason) {
|
||||
if (reason === void 0) reason = null;
|
||||
if (!dart.equals(unexpected, actual)) return;
|
||||
let msg = expect.Expect._getMessage(reason);
|
||||
expect.Expect._fail(dart.str`Expect.notEquals(unexpected: <${unexpected}>, actual:<${actual}>${msg}) ` + "fails.");
|
||||
}
|
||||
static listEquals(expected, actual, reason) {
|
||||
if (reason === void 0) reason = null;
|
||||
let msg = expect.Expect._getMessage(reason);
|
||||
let n = dart.notNull(expected[dartx.length]) < dart.notNull(actual[dartx.length]) ? expected[dartx.length] : actual[dartx.length];
|
||||
for (let i = 0; i < dart.notNull(n); i++) {
|
||||
if (!dart.equals(expected[dartx.get](i), actual[dartx.get](i))) {
|
||||
expect.Expect._fail(dart.str`Expect.listEquals(at index ${i}, ` + dart.str`expected: <${expected[dartx.get](i)}>, actual: <${actual[dartx.get](i)}>${msg}) fails`);
|
||||
}
|
||||
}
|
||||
if (expected[dartx.length] != actual[dartx.length]) {
|
||||
expect.Expect._fail('Expect.listEquals(list length, ' + dart.str`expected: <${expected[dartx.length]}>, actual: <${actual[dartx.length]}>${msg}) ` + 'fails: Next element <' + dart.str`${dart.notNull(expected[dartx.length]) > dart.notNull(n) ? expected[dartx.get](n) : actual[dartx.get](n)}>`);
|
||||
}
|
||||
}
|
||||
static mapEquals(expected, actual, reason) {
|
||||
if (reason === void 0) reason = null;
|
||||
let msg = expect.Expect._getMessage(reason);
|
||||
for (let key of expected[dartx.keys]) {
|
||||
if (!dart.test(actual[dartx.containsKey](key))) {
|
||||
expect.Expect._fail(dart.str`Expect.mapEquals(missing expected key: <${key}>${msg}) fails`);
|
||||
}
|
||||
expect.Expect.equals(expected[dartx.get](key), actual[dartx.get](key));
|
||||
}
|
||||
for (let key of actual[dartx.keys]) {
|
||||
if (!dart.test(expected[dartx.containsKey](key))) {
|
||||
expect.Expect._fail(dart.str`Expect.mapEquals(unexpected key: <${key}>${msg}) fails`);
|
||||
}
|
||||
}
|
||||
}
|
||||
static stringEquals(expected, actual, reason) {
|
||||
if (reason === void 0) reason = null;
|
||||
if (expected == actual) return;
|
||||
let msg = expect.Expect._getMessage(reason);
|
||||
let defaultMessage = dart.str`Expect.stringEquals(expected: <${expected}>", <${actual}>${msg}) fails`;
|
||||
if (expected == null || actual == null) {
|
||||
expect.Expect._fail(dart.str`${defaultMessage}`);
|
||||
}
|
||||
let left = 0;
|
||||
let right = 0;
|
||||
let eLen = expected[dartx.length];
|
||||
let aLen = actual[dartx.length];
|
||||
while (true) {
|
||||
if (left == eLen || left == aLen || expected[dartx.get](left) != actual[dartx.get](left)) {
|
||||
break;
|
||||
}
|
||||
left++;
|
||||
}
|
||||
let eRem = dart.notNull(eLen) - left;
|
||||
let aRem = dart.notNull(aLen) - left;
|
||||
while (true) {
|
||||
if (right == eRem || right == aRem || expected[dartx.get](dart.notNull(eLen) - right - 1) != actual[dartx.get](dart.notNull(aLen) - right - 1)) {
|
||||
break;
|
||||
}
|
||||
right++;
|
||||
}
|
||||
let leftSnippet = expected[dartx.substring](left < 10 ? 0 : left - 10, left);
|
||||
let rightSnippetLength = right < 10 ? right : 10;
|
||||
let rightSnippet = expected[dartx.substring](dart.notNull(eLen) - right, dart.notNull(eLen) - right + rightSnippetLength);
|
||||
let eSnippet = expected[dartx.substring](left, dart.notNull(eLen) - right);
|
||||
let aSnippet = actual[dartx.substring](left, dart.notNull(aLen) - right);
|
||||
if (dart.notNull(eSnippet[dartx.length]) > 43) {
|
||||
eSnippet = dart.notNull(eSnippet[dartx.substring](0, 20)) + "..." + dart.notNull(eSnippet[dartx.substring](dart.notNull(eSnippet[dartx.length]) - 20));
|
||||
}
|
||||
if (dart.notNull(aSnippet[dartx.length]) > 43) {
|
||||
aSnippet = dart.notNull(aSnippet[dartx.substring](0, 20)) + "..." + dart.notNull(aSnippet[dartx.substring](dart.notNull(aSnippet[dartx.length]) - 20));
|
||||
}
|
||||
let leftLead = "...";
|
||||
let rightTail = "...";
|
||||
if (left <= 10) leftLead = "";
|
||||
if (right <= 10) rightTail = "";
|
||||
let diff = dart.str`\nDiff (${left}..${dart.notNull(eLen) - right}/${dart.notNull(aLen) - right}):\n` + dart.str`${leftLead}${leftSnippet}[ ${eSnippet} ]${rightSnippet}${rightTail}\n` + dart.str`${leftLead}${leftSnippet}[ ${aSnippet} ]${rightSnippet}${rightTail}`;
|
||||
expect.Expect._fail(dart.str`${defaultMessage}${diff}`);
|
||||
}
|
||||
static setEquals(expected, actual, reason) {
|
||||
if (reason === void 0) reason = null;
|
||||
let missingSet = core.Set.from(expected);
|
||||
missingSet.removeAll(actual);
|
||||
let extraSet = core.Set.from(actual);
|
||||
extraSet.removeAll(expected);
|
||||
if (dart.test(extraSet.isEmpty) && dart.test(missingSet.isEmpty)) return;
|
||||
let msg = expect.Expect._getMessage(reason);
|
||||
let sb = new core.StringBuffer(dart.str`Expect.setEquals(${msg}) fails`);
|
||||
if (!dart.test(missingSet.isEmpty)) {
|
||||
sb.write('\nExpected collection does not contain: ');
|
||||
}
|
||||
for (let val of missingSet) {
|
||||
sb.write(dart.str`${val} `);
|
||||
}
|
||||
if (!dart.test(extraSet.isEmpty)) {
|
||||
sb.write('\nExpected collection should not contain: ');
|
||||
}
|
||||
for (let val of extraSet) {
|
||||
sb.write(dart.str`${val} `);
|
||||
}
|
||||
expect.Expect._fail(sb.toString());
|
||||
}
|
||||
static throws(f, check, reason) {
|
||||
if (check === void 0) check = null;
|
||||
if (reason === void 0) reason = null;
|
||||
let msg = reason == null ? "" : dart.str`(${reason})`;
|
||||
if (!expect._Nullary.is(f)) {
|
||||
expect.Expect._fail(dart.str`Expect.throws${msg}: Function f not callable with zero arguments`);
|
||||
}
|
||||
try {
|
||||
f();
|
||||
} catch (e) {
|
||||
let s = dart.stackTrace(e);
|
||||
if (check != null) {
|
||||
if (!dart.test(dart.dcall(check, e))) {
|
||||
expect.Expect._fail(dart.str`Expect.throws${msg}: Unexpected '${e}'\n${s}`);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
expect.Expect._fail(dart.str`Expect.throws${msg} fails: Did not throw`);
|
||||
}
|
||||
static _getMessage(reason) {
|
||||
return reason == null ? "" : dart.str`, '${reason}'`;
|
||||
}
|
||||
static _fail(message) {
|
||||
dart.throw(new expect.ExpectException(message));
|
||||
}
|
||||
};
|
||||
dart.setSignature(expect.Expect, {
|
||||
statics: () => ({
|
||||
_truncateString: dart.definiteFunctionType(core.String, [core.String, core.int, core.int, core.int]),
|
||||
_stringDifference: dart.definiteFunctionType(core.String, [core.String, core.String]),
|
||||
equals: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic], [core.String]),
|
||||
isTrue: dart.definiteFunctionType(dart.void, [dart.dynamic], [core.String]),
|
||||
isFalse: dart.definiteFunctionType(dart.void, [dart.dynamic], [core.String]),
|
||||
isNull: dart.definiteFunctionType(dart.void, [dart.dynamic], [core.String]),
|
||||
isNotNull: dart.definiteFunctionType(dart.void, [dart.dynamic], [core.String]),
|
||||
identical: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic], [core.String]),
|
||||
fail: dart.definiteFunctionType(dart.void, [core.String]),
|
||||
approxEquals: dart.definiteFunctionType(dart.void, [core.num, core.num], [core.num, core.String]),
|
||||
notEquals: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic], [core.String]),
|
||||
listEquals: dart.definiteFunctionType(dart.void, [core.List, core.List], [core.String]),
|
||||
mapEquals: dart.definiteFunctionType(dart.void, [core.Map, core.Map], [core.String]),
|
||||
stringEquals: dart.definiteFunctionType(dart.void, [core.String, core.String], [core.String]),
|
||||
setEquals: dart.definiteFunctionType(dart.void, [core.Iterable, core.Iterable], [core.String]),
|
||||
throws: dart.definiteFunctionType(dart.void, [dart.functionType(dart.void, [])], [expect._CheckExceptionFn, core.String]),
|
||||
_getMessage: dart.definiteFunctionType(core.String, [core.String]),
|
||||
_fail: dart.definiteFunctionType(dart.void, [core.String])
|
||||
}),
|
||||
names: ['_truncateString', '_stringDifference', 'equals', 'isTrue', 'isFalse', 'isNull', 'isNotNull', 'identical', 'fail', 'approxEquals', 'notEquals', 'listEquals', 'mapEquals', 'stringEquals', 'setEquals', 'throws', '_getMessage', '_fail']
|
||||
});
|
||||
expect._identical = function(a, b) {
|
||||
return core.identical(a, b);
|
||||
};
|
||||
dart.fn(expect._identical, dynamicAnddynamicTobool());
|
||||
expect._CheckExceptionFn = dart.typedef('_CheckExceptionFn', () => dart.functionType(core.bool, [dart.dynamic]));
|
||||
expect._Nullary = dart.typedef('_Nullary', () => dart.functionType(dart.dynamic, []));
|
||||
expect.ExpectException = class ExpectException extends core.Object {
|
||||
new(message) {
|
||||
this.message = message;
|
||||
}
|
||||
toString() {
|
||||
return this.message;
|
||||
}
|
||||
};
|
||||
expect.ExpectException[dart.implements] = () => [core.Exception];
|
||||
dart.setSignature(expect.ExpectException, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(expect.ExpectException, [core.String])})
|
||||
});
|
||||
expect.NoInline = class NoInline extends core.Object {
|
||||
new() {
|
||||
}
|
||||
};
|
||||
dart.setSignature(expect.NoInline, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(expect.NoInline, [])})
|
||||
});
|
||||
expect.TrustTypeAnnotations = class TrustTypeAnnotations extends core.Object {
|
||||
new() {
|
||||
}
|
||||
};
|
||||
dart.setSignature(expect.TrustTypeAnnotations, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(expect.TrustTypeAnnotations, [])})
|
||||
});
|
||||
expect.AssumeDynamic = class AssumeDynamic extends core.Object {
|
||||
new() {
|
||||
}
|
||||
};
|
||||
dart.setSignature(expect.AssumeDynamic, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(expect.AssumeDynamic, [])})
|
||||
});
|
||||
// Exports:
|
||||
exports.expect = expect;
|
||||
});
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
dart_library.library('js', null, /* Imports */[
|
||||
'dart_sdk'
|
||||
], function load__js(exports, dart_sdk) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const js = dart_sdk.js;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const js$ = Object.create(null);
|
||||
js$.JS = class JS extends core.Object {
|
||||
new(name) {
|
||||
if (name === void 0) name = null;
|
||||
this.name = name;
|
||||
}
|
||||
};
|
||||
dart.setSignature(js$.JS, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(js$.JS, [], [core.String])})
|
||||
});
|
||||
js$._Anonymous = class _Anonymous extends core.Object {
|
||||
new() {
|
||||
}
|
||||
};
|
||||
dart.setSignature(js$._Anonymous, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(js$._Anonymous, [])})
|
||||
});
|
||||
js$.anonymous = dart.const(new js$._Anonymous());
|
||||
js$.allowInteropCaptureThis = js.allowInteropCaptureThis;
|
||||
js$.allowInterop = js.allowInterop;
|
||||
// Exports:
|
||||
exports.js = js$;
|
||||
});
|
||||
|
|
@ -1 +1,15 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/application_test', null, /* Imports */[
|
||||
'dart_sdk'
|
||||
], function load__application_test(exports, dart_sdk) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const application_test = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
application_test.main = function() {
|
||||
};
|
||||
dart.fn(application_test.main, VoidTodynamic());
|
||||
// Exports:
|
||||
exports.application_test = application_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -9,561 +9,17 @@ dart_library.library('language/cyclic_import_test', null, /* Imports */[
|
|||
const expect$ = expect.expect;
|
||||
const cyclic_import_test = Object.create(null);
|
||||
const sub__sub = Object.create(null);
|
||||
const cyclic_import_test$ = Object.create(null);
|
||||
const sub__sub$ = Object.create(null);
|
||||
const cyclic_import_test$0 = Object.create(null);
|
||||
const sub__sub$0 = Object.create(null);
|
||||
const cyclic_import_test$1 = Object.create(null);
|
||||
const sub__sub$1 = Object.create(null);
|
||||
const cyclic_import_test$2 = Object.create(null);
|
||||
const sub__sub$2 = Object.create(null);
|
||||
const cyclic_import_test$3 = Object.create(null);
|
||||
const sub__sub$3 = Object.create(null);
|
||||
const cyclic_import_test$4 = Object.create(null);
|
||||
const sub__sub$4 = Object.create(null);
|
||||
const cyclic_import_test$5 = Object.create(null);
|
||||
const sub__sub$5 = Object.create(null);
|
||||
const cyclic_import_test$6 = Object.create(null);
|
||||
const sub__sub$6 = Object.create(null);
|
||||
const cyclic_import_test$7 = Object.create(null);
|
||||
const sub__sub$7 = Object.create(null);
|
||||
const cyclic_import_test$8 = Object.create(null);
|
||||
const sub__sub$8 = Object.create(null);
|
||||
const cyclic_import_test$9 = Object.create(null);
|
||||
const sub__sub$9 = Object.create(null);
|
||||
const cyclic_import_test$10 = Object.create(null);
|
||||
const sub__sub$10 = Object.create(null);
|
||||
const cyclic_import_test$11 = Object.create(null);
|
||||
const sub__sub$11 = Object.create(null);
|
||||
const cyclic_import_test$12 = Object.create(null);
|
||||
const sub__sub$12 = Object.create(null);
|
||||
const cyclic_import_test$13 = Object.create(null);
|
||||
const sub__sub$13 = Object.create(null);
|
||||
const cyclic_import_test$14 = Object.create(null);
|
||||
const sub__sub$14 = Object.create(null);
|
||||
const cyclic_import_test$15 = Object.create(null);
|
||||
const sub__sub$15 = Object.create(null);
|
||||
const cyclic_import_test$16 = Object.create(null);
|
||||
const sub__sub$16 = Object.create(null);
|
||||
const cyclic_import_test$17 = Object.create(null);
|
||||
const sub__sub$17 = Object.create(null);
|
||||
const cyclic_import_test$18 = Object.create(null);
|
||||
const sub__sub$18 = Object.create(null);
|
||||
const cyclic_import_test$19 = Object.create(null);
|
||||
const sub__sub$19 = Object.create(null);
|
||||
const cyclic_import_test$20 = Object.create(null);
|
||||
const sub__sub$20 = Object.create(null);
|
||||
const cyclic_import_test$21 = Object.create(null);
|
||||
const sub__sub$21 = Object.create(null);
|
||||
const cyclic_import_test$22 = Object.create(null);
|
||||
const sub__sub$22 = Object.create(null);
|
||||
const cyclic_import_test$23 = Object.create(null);
|
||||
const sub__sub$23 = Object.create(null);
|
||||
const cyclic_import_test$24 = Object.create(null);
|
||||
const sub__sub$24 = Object.create(null);
|
||||
const cyclic_import_test$25 = Object.create(null);
|
||||
const sub__sub$25 = Object.create(null);
|
||||
const cyclic_import_test$26 = Object.create(null);
|
||||
const sub__sub$26 = Object.create(null);
|
||||
const cyclic_import_test$27 = Object.create(null);
|
||||
const sub__sub$27 = Object.create(null);
|
||||
const cyclic_import_test$28 = Object.create(null);
|
||||
const sub__sub$28 = Object.create(null);
|
||||
const cyclic_import_test$29 = Object.create(null);
|
||||
const sub__sub$29 = Object.create(null);
|
||||
const cyclic_import_test$30 = Object.create(null);
|
||||
const sub__sub$30 = Object.create(null);
|
||||
const cyclic_import_test$31 = Object.create(null);
|
||||
const sub__sub$31 = Object.create(null);
|
||||
const cyclic_import_test$32 = Object.create(null);
|
||||
const sub__sub$32 = Object.create(null);
|
||||
const cyclic_import_test$33 = Object.create(null);
|
||||
const sub__sub$33 = Object.create(null);
|
||||
const cyclic_import_test$34 = Object.create(null);
|
||||
const sub__sub$34 = Object.create(null);
|
||||
const cyclic_import_test$35 = Object.create(null);
|
||||
const sub__sub$35 = Object.create(null);
|
||||
const cyclic_import_test$36 = Object.create(null);
|
||||
const sub__sub$36 = Object.create(null);
|
||||
const cyclic_import_test$37 = Object.create(null);
|
||||
const sub__sub$37 = Object.create(null);
|
||||
const cyclic_import_test$38 = Object.create(null);
|
||||
const sub__sub$38 = Object.create(null);
|
||||
const cyclic_import_test$39 = Object.create(null);
|
||||
const sub__sub$39 = Object.create(null);
|
||||
const cyclic_import_test$40 = Object.create(null);
|
||||
const sub__sub$40 = Object.create(null);
|
||||
const cyclic_import_test$41 = Object.create(null);
|
||||
const sub__sub$41 = Object.create(null);
|
||||
const cyclic_import_test$42 = Object.create(null);
|
||||
const sub__sub$42 = Object.create(null);
|
||||
const cyclic_import_test$43 = Object.create(null);
|
||||
const sub__sub$43 = Object.create(null);
|
||||
const cyclic_import_test$44 = Object.create(null);
|
||||
const sub__sub$44 = Object.create(null);
|
||||
const cyclic_import_test$45 = Object.create(null);
|
||||
const sub__sub$45 = Object.create(null);
|
||||
const cyclic_import_test$46 = Object.create(null);
|
||||
const sub__sub$46 = Object.create(null);
|
||||
const cyclic_import_test$47 = Object.create(null);
|
||||
const sub__sub$47 = Object.create(null);
|
||||
const cyclic_import_test$48 = Object.create(null);
|
||||
const sub__sub$48 = Object.create(null);
|
||||
const cyclic_import_test$49 = Object.create(null);
|
||||
const sub__sub$49 = Object.create(null);
|
||||
const cyclic_import_test$50 = Object.create(null);
|
||||
const sub__sub$50 = Object.create(null);
|
||||
const cyclic_import_test$51 = Object.create(null);
|
||||
const sub__sub$51 = Object.create(null);
|
||||
const cyclic_import_test$52 = Object.create(null);
|
||||
const sub__sub$52 = Object.create(null);
|
||||
const cyclic_import_test$53 = Object.create(null);
|
||||
const sub__sub$53 = Object.create(null);
|
||||
const cyclic_import_test$54 = Object.create(null);
|
||||
const sub__sub$54 = Object.create(null);
|
||||
const cyclic_import_test$55 = Object.create(null);
|
||||
const sub__sub$55 = Object.create(null);
|
||||
const cyclic_import_test$56 = Object.create(null);
|
||||
const sub__sub$56 = Object.create(null);
|
||||
const cyclic_import_test$57 = Object.create(null);
|
||||
const sub__sub$57 = Object.create(null);
|
||||
const cyclic_import_test$58 = Object.create(null);
|
||||
const sub__sub$58 = Object.create(null);
|
||||
const cyclic_import_test$59 = Object.create(null);
|
||||
const sub__sub$59 = Object.create(null);
|
||||
const cyclic_import_test$60 = Object.create(null);
|
||||
const sub__sub$60 = Object.create(null);
|
||||
const cyclic_import_test$61 = Object.create(null);
|
||||
const sub__sub$61 = Object.create(null);
|
||||
const cyclic_import_test$62 = Object.create(null);
|
||||
const sub__sub$62 = Object.create(null);
|
||||
const cyclic_import_test$63 = Object.create(null);
|
||||
const sub__sub$63 = Object.create(null);
|
||||
const cyclic_import_test$64 = Object.create(null);
|
||||
const sub__sub$64 = Object.create(null);
|
||||
const cyclic_import_test$65 = Object.create(null);
|
||||
const sub__sub$65 = Object.create(null);
|
||||
const cyclic_import_test$66 = Object.create(null);
|
||||
const sub__sub$66 = Object.create(null);
|
||||
const cyclic_import_test$67 = Object.create(null);
|
||||
const sub__sub$67 = Object.create(null);
|
||||
const cyclic_import_test$68 = Object.create(null);
|
||||
const sub__sub$68 = Object.create(null);
|
||||
const cyclic_import_test$69 = Object.create(null);
|
||||
const sub__sub$69 = Object.create(null);
|
||||
const cyclic_import_test$70 = Object.create(null);
|
||||
const sub__sub$70 = Object.create(null);
|
||||
const cyclic_import_test$71 = Object.create(null);
|
||||
const sub__sub$71 = Object.create(null);
|
||||
const cyclic_import_test$72 = Object.create(null);
|
||||
const sub__sub$72 = Object.create(null);
|
||||
const cyclic_import_test$73 = Object.create(null);
|
||||
const sub__sub$73 = Object.create(null);
|
||||
const cyclic_import_test$74 = Object.create(null);
|
||||
const sub__sub$74 = Object.create(null);
|
||||
const cyclic_import_test$75 = Object.create(null);
|
||||
const sub__sub$75 = Object.create(null);
|
||||
const cyclic_import_test$76 = Object.create(null);
|
||||
const sub__sub$76 = Object.create(null);
|
||||
const cyclic_import_test$77 = Object.create(null);
|
||||
const sub__sub$77 = Object.create(null);
|
||||
const cyclic_import_test$78 = Object.create(null);
|
||||
const sub__sub$78 = Object.create(null);
|
||||
const cyclic_import_test$79 = Object.create(null);
|
||||
const sub__sub$79 = Object.create(null);
|
||||
const cyclic_import_test$80 = Object.create(null);
|
||||
const sub__sub$80 = Object.create(null);
|
||||
const cyclic_import_test$81 = Object.create(null);
|
||||
const sub__sub$81 = Object.create(null);
|
||||
const cyclic_import_test$82 = Object.create(null);
|
||||
const sub__sub$82 = Object.create(null);
|
||||
const cyclic_import_test$83 = Object.create(null);
|
||||
const sub__sub$83 = Object.create(null);
|
||||
const cyclic_import_test$84 = Object.create(null);
|
||||
const sub__sub$84 = Object.create(null);
|
||||
const cyclic_import_test$85 = Object.create(null);
|
||||
const sub__sub$85 = Object.create(null);
|
||||
const cyclic_import_test$86 = Object.create(null);
|
||||
const sub__sub$86 = Object.create(null);
|
||||
const cyclic_import_test$87 = Object.create(null);
|
||||
const sub__sub$87 = Object.create(null);
|
||||
const cyclic_import_test$88 = Object.create(null);
|
||||
const sub__sub$88 = Object.create(null);
|
||||
const cyclic_import_test$89 = Object.create(null);
|
||||
const sub__sub$89 = Object.create(null);
|
||||
const cyclic_import_test$90 = Object.create(null);
|
||||
const sub__sub$90 = Object.create(null);
|
||||
const cyclic_import_test$91 = Object.create(null);
|
||||
const sub__sub$91 = Object.create(null);
|
||||
const cyclic_import_test$92 = Object.create(null);
|
||||
const sub__sub$92 = Object.create(null);
|
||||
const cyclic_import_test$93 = Object.create(null);
|
||||
const sub__sub$93 = Object.create(null);
|
||||
const cyclic_import_test$94 = Object.create(null);
|
||||
const sub__sub$94 = Object.create(null);
|
||||
const cyclic_import_test$95 = Object.create(null);
|
||||
const sub__sub$95 = Object.create(null);
|
||||
const cyclic_import_test$96 = Object.create(null);
|
||||
const sub__sub$96 = Object.create(null);
|
||||
const cyclic_import_test$97 = Object.create(null);
|
||||
const sub__sub$97 = Object.create(null);
|
||||
const cyclic_import_test$98 = Object.create(null);
|
||||
const sub__sub$98 = Object.create(null);
|
||||
const cyclic_import_test$99 = Object.create(null);
|
||||
const sub__sub$99 = Object.create(null);
|
||||
const cyclic_import_test$100 = Object.create(null);
|
||||
const sub__sub$100 = Object.create(null);
|
||||
const cyclic_import_test$101 = Object.create(null);
|
||||
const sub__sub$101 = Object.create(null);
|
||||
const cyclic_import_test$102 = Object.create(null);
|
||||
const sub__sub$102 = Object.create(null);
|
||||
const cyclic_import_test$103 = Object.create(null);
|
||||
const sub__sub$103 = Object.create(null);
|
||||
const cyclic_import_test$104 = Object.create(null);
|
||||
const sub__sub$104 = Object.create(null);
|
||||
const cyclic_import_test$105 = Object.create(null);
|
||||
const sub__sub$105 = Object.create(null);
|
||||
const cyclic_import_test$106 = Object.create(null);
|
||||
const sub__sub$106 = Object.create(null);
|
||||
const cyclic_import_test$107 = Object.create(null);
|
||||
const sub__sub$107 = Object.create(null);
|
||||
const cyclic_import_test$108 = Object.create(null);
|
||||
const sub__sub$108 = Object.create(null);
|
||||
const cyclic_import_test$109 = Object.create(null);
|
||||
const sub__sub$109 = Object.create(null);
|
||||
const cyclic_import_test$110 = Object.create(null);
|
||||
const sub__sub$110 = Object.create(null);
|
||||
const cyclic_import_test$111 = Object.create(null);
|
||||
const sub__sub$111 = Object.create(null);
|
||||
const cyclic_import_test$112 = Object.create(null);
|
||||
const sub__sub$112 = Object.create(null);
|
||||
const cyclic_import_test$113 = Object.create(null);
|
||||
const sub__sub$113 = Object.create(null);
|
||||
const cyclic_import_test$114 = Object.create(null);
|
||||
const sub__sub$114 = Object.create(null);
|
||||
const cyclic_import_test$115 = Object.create(null);
|
||||
const sub__sub$115 = Object.create(null);
|
||||
const cyclic_import_test$116 = Object.create(null);
|
||||
const sub__sub$116 = Object.create(null);
|
||||
const cyclic_import_test$117 = Object.create(null);
|
||||
const sub__sub$117 = Object.create(null);
|
||||
const cyclic_import_test$118 = Object.create(null);
|
||||
const sub__sub$118 = Object.create(null);
|
||||
const cyclic_import_test$119 = Object.create(null);
|
||||
const sub__sub$119 = Object.create(null);
|
||||
const cyclic_import_test$120 = Object.create(null);
|
||||
const sub__sub$120 = Object.create(null);
|
||||
const cyclic_import_test$121 = Object.create(null);
|
||||
const sub__sub$121 = Object.create(null);
|
||||
const cyclic_import_test$122 = Object.create(null);
|
||||
const sub__sub$122 = Object.create(null);
|
||||
const cyclic_import_test$123 = Object.create(null);
|
||||
const sub__sub$123 = Object.create(null);
|
||||
const cyclic_import_test$124 = Object.create(null);
|
||||
const sub__sub$124 = Object.create(null);
|
||||
const cyclic_import_test$125 = Object.create(null);
|
||||
const sub__sub$125 = Object.create(null);
|
||||
const cyclic_import_test$126 = Object.create(null);
|
||||
const sub__sub$126 = Object.create(null);
|
||||
const cyclic_import_test$127 = Object.create(null);
|
||||
const sub__sub$127 = Object.create(null);
|
||||
const cyclic_import_test$128 = Object.create(null);
|
||||
const sub__sub$128 = Object.create(null);
|
||||
const cyclic_import_test$129 = Object.create(null);
|
||||
const sub__sub$129 = Object.create(null);
|
||||
const cyclic_import_test$130 = Object.create(null);
|
||||
const sub__sub$130 = Object.create(null);
|
||||
const cyclic_import_test$131 = Object.create(null);
|
||||
const sub__sub$131 = Object.create(null);
|
||||
const cyclic_import_test$132 = Object.create(null);
|
||||
const sub__sub$132 = Object.create(null);
|
||||
const cyclic_import_test$133 = Object.create(null);
|
||||
const sub__sub$133 = Object.create(null);
|
||||
const cyclic_import_test$134 = Object.create(null);
|
||||
const sub__sub$134 = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
cyclic_import_test$134.value = 42;
|
||||
cyclic_import_test$134.main = function() {
|
||||
sub__sub$134.subMain();
|
||||
cyclic_import_test.value = 42;
|
||||
cyclic_import_test.main = function() {
|
||||
sub__sub.subMain();
|
||||
};
|
||||
dart.fn(cyclic_import_test$134.main, VoidTodynamic());
|
||||
sub__sub$134.subMain = function() {
|
||||
expect$.Expect.equals(42, cyclic_import_test$134.value);
|
||||
dart.fn(cyclic_import_test.main, VoidTodynamic());
|
||||
sub__sub.subMain = function() {
|
||||
expect$.Expect.equals(42, cyclic_import_test.value);
|
||||
};
|
||||
dart.fn(sub__sub$134.subMain, VoidTodynamic());
|
||||
dart.fn(sub__sub.subMain, VoidTodynamic());
|
||||
// Exports:
|
||||
exports.cyclic_import_test = cyclic_import_test;
|
||||
exports.sub__sub = sub__sub;
|
||||
exports.cyclic_import_test = cyclic_import_test$;
|
||||
exports.sub__sub = sub__sub$;
|
||||
exports.cyclic_import_test = cyclic_import_test$0;
|
||||
exports.sub__sub = sub__sub$0;
|
||||
exports.cyclic_import_test = cyclic_import_test$1;
|
||||
exports.sub__sub = sub__sub$1;
|
||||
exports.cyclic_import_test = cyclic_import_test$2;
|
||||
exports.sub__sub = sub__sub$2;
|
||||
exports.cyclic_import_test = cyclic_import_test$3;
|
||||
exports.sub__sub = sub__sub$3;
|
||||
exports.cyclic_import_test = cyclic_import_test$4;
|
||||
exports.sub__sub = sub__sub$4;
|
||||
exports.cyclic_import_test = cyclic_import_test$5;
|
||||
exports.sub__sub = sub__sub$5;
|
||||
exports.cyclic_import_test = cyclic_import_test$6;
|
||||
exports.sub__sub = sub__sub$6;
|
||||
exports.cyclic_import_test = cyclic_import_test$7;
|
||||
exports.sub__sub = sub__sub$7;
|
||||
exports.cyclic_import_test = cyclic_import_test$8;
|
||||
exports.sub__sub = sub__sub$8;
|
||||
exports.cyclic_import_test = cyclic_import_test$9;
|
||||
exports.sub__sub = sub__sub$9;
|
||||
exports.cyclic_import_test = cyclic_import_test$10;
|
||||
exports.sub__sub = sub__sub$10;
|
||||
exports.cyclic_import_test = cyclic_import_test$11;
|
||||
exports.sub__sub = sub__sub$11;
|
||||
exports.cyclic_import_test = cyclic_import_test$12;
|
||||
exports.sub__sub = sub__sub$12;
|
||||
exports.cyclic_import_test = cyclic_import_test$13;
|
||||
exports.sub__sub = sub__sub$13;
|
||||
exports.cyclic_import_test = cyclic_import_test$14;
|
||||
exports.sub__sub = sub__sub$14;
|
||||
exports.cyclic_import_test = cyclic_import_test$15;
|
||||
exports.sub__sub = sub__sub$15;
|
||||
exports.cyclic_import_test = cyclic_import_test$16;
|
||||
exports.sub__sub = sub__sub$16;
|
||||
exports.cyclic_import_test = cyclic_import_test$17;
|
||||
exports.sub__sub = sub__sub$17;
|
||||
exports.cyclic_import_test = cyclic_import_test$18;
|
||||
exports.sub__sub = sub__sub$18;
|
||||
exports.cyclic_import_test = cyclic_import_test$19;
|
||||
exports.sub__sub = sub__sub$19;
|
||||
exports.cyclic_import_test = cyclic_import_test$20;
|
||||
exports.sub__sub = sub__sub$20;
|
||||
exports.cyclic_import_test = cyclic_import_test$21;
|
||||
exports.sub__sub = sub__sub$21;
|
||||
exports.cyclic_import_test = cyclic_import_test$22;
|
||||
exports.sub__sub = sub__sub$22;
|
||||
exports.cyclic_import_test = cyclic_import_test$23;
|
||||
exports.sub__sub = sub__sub$23;
|
||||
exports.cyclic_import_test = cyclic_import_test$24;
|
||||
exports.sub__sub = sub__sub$24;
|
||||
exports.cyclic_import_test = cyclic_import_test$25;
|
||||
exports.sub__sub = sub__sub$25;
|
||||
exports.cyclic_import_test = cyclic_import_test$26;
|
||||
exports.sub__sub = sub__sub$26;
|
||||
exports.cyclic_import_test = cyclic_import_test$27;
|
||||
exports.sub__sub = sub__sub$27;
|
||||
exports.cyclic_import_test = cyclic_import_test$28;
|
||||
exports.sub__sub = sub__sub$28;
|
||||
exports.cyclic_import_test = cyclic_import_test$29;
|
||||
exports.sub__sub = sub__sub$29;
|
||||
exports.cyclic_import_test = cyclic_import_test$30;
|
||||
exports.sub__sub = sub__sub$30;
|
||||
exports.cyclic_import_test = cyclic_import_test$31;
|
||||
exports.sub__sub = sub__sub$31;
|
||||
exports.cyclic_import_test = cyclic_import_test$32;
|
||||
exports.sub__sub = sub__sub$32;
|
||||
exports.cyclic_import_test = cyclic_import_test$33;
|
||||
exports.sub__sub = sub__sub$33;
|
||||
exports.cyclic_import_test = cyclic_import_test$34;
|
||||
exports.sub__sub = sub__sub$34;
|
||||
exports.cyclic_import_test = cyclic_import_test$35;
|
||||
exports.sub__sub = sub__sub$35;
|
||||
exports.cyclic_import_test = cyclic_import_test$36;
|
||||
exports.sub__sub = sub__sub$36;
|
||||
exports.cyclic_import_test = cyclic_import_test$37;
|
||||
exports.sub__sub = sub__sub$37;
|
||||
exports.cyclic_import_test = cyclic_import_test$38;
|
||||
exports.sub__sub = sub__sub$38;
|
||||
exports.cyclic_import_test = cyclic_import_test$39;
|
||||
exports.sub__sub = sub__sub$39;
|
||||
exports.cyclic_import_test = cyclic_import_test$40;
|
||||
exports.sub__sub = sub__sub$40;
|
||||
exports.cyclic_import_test = cyclic_import_test$41;
|
||||
exports.sub__sub = sub__sub$41;
|
||||
exports.cyclic_import_test = cyclic_import_test$42;
|
||||
exports.sub__sub = sub__sub$42;
|
||||
exports.cyclic_import_test = cyclic_import_test$43;
|
||||
exports.sub__sub = sub__sub$43;
|
||||
exports.cyclic_import_test = cyclic_import_test$44;
|
||||
exports.sub__sub = sub__sub$44;
|
||||
exports.cyclic_import_test = cyclic_import_test$45;
|
||||
exports.sub__sub = sub__sub$45;
|
||||
exports.cyclic_import_test = cyclic_import_test$46;
|
||||
exports.sub__sub = sub__sub$46;
|
||||
exports.cyclic_import_test = cyclic_import_test$47;
|
||||
exports.sub__sub = sub__sub$47;
|
||||
exports.cyclic_import_test = cyclic_import_test$48;
|
||||
exports.sub__sub = sub__sub$48;
|
||||
exports.cyclic_import_test = cyclic_import_test$49;
|
||||
exports.sub__sub = sub__sub$49;
|
||||
exports.cyclic_import_test = cyclic_import_test$50;
|
||||
exports.sub__sub = sub__sub$50;
|
||||
exports.cyclic_import_test = cyclic_import_test$51;
|
||||
exports.sub__sub = sub__sub$51;
|
||||
exports.cyclic_import_test = cyclic_import_test$52;
|
||||
exports.sub__sub = sub__sub$52;
|
||||
exports.cyclic_import_test = cyclic_import_test$53;
|
||||
exports.sub__sub = sub__sub$53;
|
||||
exports.cyclic_import_test = cyclic_import_test$54;
|
||||
exports.sub__sub = sub__sub$54;
|
||||
exports.cyclic_import_test = cyclic_import_test$55;
|
||||
exports.sub__sub = sub__sub$55;
|
||||
exports.cyclic_import_test = cyclic_import_test$56;
|
||||
exports.sub__sub = sub__sub$56;
|
||||
exports.cyclic_import_test = cyclic_import_test$57;
|
||||
exports.sub__sub = sub__sub$57;
|
||||
exports.cyclic_import_test = cyclic_import_test$58;
|
||||
exports.sub__sub = sub__sub$58;
|
||||
exports.cyclic_import_test = cyclic_import_test$59;
|
||||
exports.sub__sub = sub__sub$59;
|
||||
exports.cyclic_import_test = cyclic_import_test$60;
|
||||
exports.sub__sub = sub__sub$60;
|
||||
exports.cyclic_import_test = cyclic_import_test$61;
|
||||
exports.sub__sub = sub__sub$61;
|
||||
exports.cyclic_import_test = cyclic_import_test$62;
|
||||
exports.sub__sub = sub__sub$62;
|
||||
exports.cyclic_import_test = cyclic_import_test$63;
|
||||
exports.sub__sub = sub__sub$63;
|
||||
exports.cyclic_import_test = cyclic_import_test$64;
|
||||
exports.sub__sub = sub__sub$64;
|
||||
exports.cyclic_import_test = cyclic_import_test$65;
|
||||
exports.sub__sub = sub__sub$65;
|
||||
exports.cyclic_import_test = cyclic_import_test$66;
|
||||
exports.sub__sub = sub__sub$66;
|
||||
exports.cyclic_import_test = cyclic_import_test$67;
|
||||
exports.sub__sub = sub__sub$67;
|
||||
exports.cyclic_import_test = cyclic_import_test$68;
|
||||
exports.sub__sub = sub__sub$68;
|
||||
exports.cyclic_import_test = cyclic_import_test$69;
|
||||
exports.sub__sub = sub__sub$69;
|
||||
exports.cyclic_import_test = cyclic_import_test$70;
|
||||
exports.sub__sub = sub__sub$70;
|
||||
exports.cyclic_import_test = cyclic_import_test$71;
|
||||
exports.sub__sub = sub__sub$71;
|
||||
exports.cyclic_import_test = cyclic_import_test$72;
|
||||
exports.sub__sub = sub__sub$72;
|
||||
exports.cyclic_import_test = cyclic_import_test$73;
|
||||
exports.sub__sub = sub__sub$73;
|
||||
exports.cyclic_import_test = cyclic_import_test$74;
|
||||
exports.sub__sub = sub__sub$74;
|
||||
exports.cyclic_import_test = cyclic_import_test$75;
|
||||
exports.sub__sub = sub__sub$75;
|
||||
exports.cyclic_import_test = cyclic_import_test$76;
|
||||
exports.sub__sub = sub__sub$76;
|
||||
exports.cyclic_import_test = cyclic_import_test$77;
|
||||
exports.sub__sub = sub__sub$77;
|
||||
exports.cyclic_import_test = cyclic_import_test$78;
|
||||
exports.sub__sub = sub__sub$78;
|
||||
exports.cyclic_import_test = cyclic_import_test$79;
|
||||
exports.sub__sub = sub__sub$79;
|
||||
exports.cyclic_import_test = cyclic_import_test$80;
|
||||
exports.sub__sub = sub__sub$80;
|
||||
exports.cyclic_import_test = cyclic_import_test$81;
|
||||
exports.sub__sub = sub__sub$81;
|
||||
exports.cyclic_import_test = cyclic_import_test$82;
|
||||
exports.sub__sub = sub__sub$82;
|
||||
exports.cyclic_import_test = cyclic_import_test$83;
|
||||
exports.sub__sub = sub__sub$83;
|
||||
exports.cyclic_import_test = cyclic_import_test$84;
|
||||
exports.sub__sub = sub__sub$84;
|
||||
exports.cyclic_import_test = cyclic_import_test$85;
|
||||
exports.sub__sub = sub__sub$85;
|
||||
exports.cyclic_import_test = cyclic_import_test$86;
|
||||
exports.sub__sub = sub__sub$86;
|
||||
exports.cyclic_import_test = cyclic_import_test$87;
|
||||
exports.sub__sub = sub__sub$87;
|
||||
exports.cyclic_import_test = cyclic_import_test$88;
|
||||
exports.sub__sub = sub__sub$88;
|
||||
exports.cyclic_import_test = cyclic_import_test$89;
|
||||
exports.sub__sub = sub__sub$89;
|
||||
exports.cyclic_import_test = cyclic_import_test$90;
|
||||
exports.sub__sub = sub__sub$90;
|
||||
exports.cyclic_import_test = cyclic_import_test$91;
|
||||
exports.sub__sub = sub__sub$91;
|
||||
exports.cyclic_import_test = cyclic_import_test$92;
|
||||
exports.sub__sub = sub__sub$92;
|
||||
exports.cyclic_import_test = cyclic_import_test$93;
|
||||
exports.sub__sub = sub__sub$93;
|
||||
exports.cyclic_import_test = cyclic_import_test$94;
|
||||
exports.sub__sub = sub__sub$94;
|
||||
exports.cyclic_import_test = cyclic_import_test$95;
|
||||
exports.sub__sub = sub__sub$95;
|
||||
exports.cyclic_import_test = cyclic_import_test$96;
|
||||
exports.sub__sub = sub__sub$96;
|
||||
exports.cyclic_import_test = cyclic_import_test$97;
|
||||
exports.sub__sub = sub__sub$97;
|
||||
exports.cyclic_import_test = cyclic_import_test$98;
|
||||
exports.sub__sub = sub__sub$98;
|
||||
exports.cyclic_import_test = cyclic_import_test$99;
|
||||
exports.sub__sub = sub__sub$99;
|
||||
exports.cyclic_import_test = cyclic_import_test$100;
|
||||
exports.sub__sub = sub__sub$100;
|
||||
exports.cyclic_import_test = cyclic_import_test$101;
|
||||
exports.sub__sub = sub__sub$101;
|
||||
exports.cyclic_import_test = cyclic_import_test$102;
|
||||
exports.sub__sub = sub__sub$102;
|
||||
exports.cyclic_import_test = cyclic_import_test$103;
|
||||
exports.sub__sub = sub__sub$103;
|
||||
exports.cyclic_import_test = cyclic_import_test$104;
|
||||
exports.sub__sub = sub__sub$104;
|
||||
exports.cyclic_import_test = cyclic_import_test$105;
|
||||
exports.sub__sub = sub__sub$105;
|
||||
exports.cyclic_import_test = cyclic_import_test$106;
|
||||
exports.sub__sub = sub__sub$106;
|
||||
exports.cyclic_import_test = cyclic_import_test$107;
|
||||
exports.sub__sub = sub__sub$107;
|
||||
exports.cyclic_import_test = cyclic_import_test$108;
|
||||
exports.sub__sub = sub__sub$108;
|
||||
exports.cyclic_import_test = cyclic_import_test$109;
|
||||
exports.sub__sub = sub__sub$109;
|
||||
exports.cyclic_import_test = cyclic_import_test$110;
|
||||
exports.sub__sub = sub__sub$110;
|
||||
exports.cyclic_import_test = cyclic_import_test$111;
|
||||
exports.sub__sub = sub__sub$111;
|
||||
exports.cyclic_import_test = cyclic_import_test$112;
|
||||
exports.sub__sub = sub__sub$112;
|
||||
exports.cyclic_import_test = cyclic_import_test$113;
|
||||
exports.sub__sub = sub__sub$113;
|
||||
exports.cyclic_import_test = cyclic_import_test$114;
|
||||
exports.sub__sub = sub__sub$114;
|
||||
exports.cyclic_import_test = cyclic_import_test$115;
|
||||
exports.sub__sub = sub__sub$115;
|
||||
exports.cyclic_import_test = cyclic_import_test$116;
|
||||
exports.sub__sub = sub__sub$116;
|
||||
exports.cyclic_import_test = cyclic_import_test$117;
|
||||
exports.sub__sub = sub__sub$117;
|
||||
exports.cyclic_import_test = cyclic_import_test$118;
|
||||
exports.sub__sub = sub__sub$118;
|
||||
exports.cyclic_import_test = cyclic_import_test$119;
|
||||
exports.sub__sub = sub__sub$119;
|
||||
exports.cyclic_import_test = cyclic_import_test$120;
|
||||
exports.sub__sub = sub__sub$120;
|
||||
exports.cyclic_import_test = cyclic_import_test$121;
|
||||
exports.sub__sub = sub__sub$121;
|
||||
exports.cyclic_import_test = cyclic_import_test$122;
|
||||
exports.sub__sub = sub__sub$122;
|
||||
exports.cyclic_import_test = cyclic_import_test$123;
|
||||
exports.sub__sub = sub__sub$123;
|
||||
exports.cyclic_import_test = cyclic_import_test$124;
|
||||
exports.sub__sub = sub__sub$124;
|
||||
exports.cyclic_import_test = cyclic_import_test$125;
|
||||
exports.sub__sub = sub__sub$125;
|
||||
exports.cyclic_import_test = cyclic_import_test$126;
|
||||
exports.sub__sub = sub__sub$126;
|
||||
exports.cyclic_import_test = cyclic_import_test$127;
|
||||
exports.sub__sub = sub__sub$127;
|
||||
exports.cyclic_import_test = cyclic_import_test$128;
|
||||
exports.sub__sub = sub__sub$128;
|
||||
exports.cyclic_import_test = cyclic_import_test$129;
|
||||
exports.sub__sub = sub__sub$129;
|
||||
exports.cyclic_import_test = cyclic_import_test$130;
|
||||
exports.sub__sub = sub__sub$130;
|
||||
exports.cyclic_import_test = cyclic_import_test$131;
|
||||
exports.sub__sub = sub__sub$131;
|
||||
exports.cyclic_import_test = cyclic_import_test$132;
|
||||
exports.sub__sub = sub__sub$132;
|
||||
exports.cyclic_import_test = cyclic_import_test$133;
|
||||
exports.sub__sub = sub__sub$133;
|
||||
exports.cyclic_import_test = cyclic_import_test$134;
|
||||
exports.sub__sub = sub__sub$134;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,22 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/export_double_same_main_test', null, /* Imports */[
|
||||
'dart_sdk'
|
||||
], function load__export_double_same_main_test(exports, dart_sdk) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const export_double_same_main_test = Object.create(null);
|
||||
const top_level_entry_test = Object.create(null);
|
||||
const export_main_test = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
top_level_entry_test.main = function() {
|
||||
};
|
||||
dart.fn(top_level_entry_test.main, VoidTodynamic());
|
||||
export_double_same_main_test.main = top_level_entry_test.main;
|
||||
export_double_same_main_test.main = top_level_entry_test.main;
|
||||
export_main_test.main = top_level_entry_test.main;
|
||||
// Exports:
|
||||
exports.export_double_same_main_test = export_double_same_main_test;
|
||||
exports.top_level_entry_test = top_level_entry_test;
|
||||
exports.export_main_test = export_main_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,21 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/export_main_override_test', null, /* Imports */[
|
||||
'dart_sdk'
|
||||
], function load__export_main_override_test(exports, dart_sdk) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const export_main_override_test = Object.create(null);
|
||||
const top_level_entry_test = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
export_main_override_test.main = function() {
|
||||
core.print('export_main_override');
|
||||
};
|
||||
dart.fn(export_main_override_test.main, VoidTodynamic());
|
||||
top_level_entry_test.main = function() {
|
||||
};
|
||||
dart.fn(top_level_entry_test.main, VoidTodynamic());
|
||||
// Exports:
|
||||
exports.export_main_override_test = export_main_override_test;
|
||||
exports.top_level_entry_test = top_level_entry_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,18 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/export_main_test', null, /* Imports */[
|
||||
'dart_sdk'
|
||||
], function load__export_main_test(exports, dart_sdk) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const export_main_test = Object.create(null);
|
||||
const top_level_entry_test = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
top_level_entry_test.main = function() {
|
||||
};
|
||||
dart.fn(top_level_entry_test.main, VoidTodynamic());
|
||||
export_main_test.main = top_level_entry_test.main;
|
||||
// Exports:
|
||||
exports.export_main_test = export_main_test;
|
||||
exports.top_level_entry_test = top_level_entry_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,164 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/generic_instanceof_test', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'expect'
|
||||
], function load__generic_instanceof_test(exports, dart_sdk, expect) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect$ = expect.expect;
|
||||
const generic_instanceof_test = Object.create(null);
|
||||
let Foo = () => (Foo = dart.constFn(generic_instanceof_test.Foo$()))();
|
||||
let FooOfString = () => (FooOfString = dart.constFn(generic_instanceof_test.Foo$(core.String)))();
|
||||
let ListOfObject = () => (ListOfObject = dart.constFn(core.List$(core.Object)))();
|
||||
let ListOfint = () => (ListOfint = dart.constFn(core.List$(core.int)))();
|
||||
let ListOfnum = () => (ListOfnum = dart.constFn(core.List$(core.num)))();
|
||||
let ListOfString = () => (ListOfString = dart.constFn(core.List$(core.String)))();
|
||||
let FooOfList = () => (FooOfList = dart.constFn(generic_instanceof_test.Foo$(core.List)))();
|
||||
let FooOfListOfObject = () => (FooOfListOfObject = dart.constFn(generic_instanceof_test.Foo$(ListOfObject())))();
|
||||
let FooOfListOfint = () => (FooOfListOfint = dart.constFn(generic_instanceof_test.Foo$(ListOfint())))();
|
||||
let FooOfListOfnum = () => (FooOfListOfnum = dart.constFn(generic_instanceof_test.Foo$(ListOfnum())))();
|
||||
let FooOfListOfString = () => (FooOfListOfString = dart.constFn(generic_instanceof_test.Foo$(ListOfString())))();
|
||||
let FooOfObject = () => (FooOfObject = dart.constFn(generic_instanceof_test.Foo$(core.Object)))();
|
||||
let FooOfint = () => (FooOfint = dart.constFn(generic_instanceof_test.Foo$(core.int)))();
|
||||
let FooOfnum = () => (FooOfnum = dart.constFn(generic_instanceof_test.Foo$(core.num)))();
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
generic_instanceof_test.main = function() {
|
||||
for (let i = 0; i < 5; i++) {
|
||||
generic_instanceof_test.GenericInstanceof.testMain();
|
||||
}
|
||||
};
|
||||
dart.fn(generic_instanceof_test.main, VoidTodynamic());
|
||||
generic_instanceof_test.Foo$ = dart.generic(T => {
|
||||
let ListOfT = () => (ListOfT = dart.constFn(core.List$(T)))();
|
||||
class Foo extends core.Object {
|
||||
new() {
|
||||
}
|
||||
isT(x) {
|
||||
return T.is(x);
|
||||
}
|
||||
isListT(x) {
|
||||
return ListOfT().is(x);
|
||||
}
|
||||
}
|
||||
dart.addTypeTests(Foo);
|
||||
dart.setSignature(Foo, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(generic_instanceof_test.Foo$(T), [])}),
|
||||
methods: () => ({
|
||||
isT: dart.definiteFunctionType(core.bool, [dart.dynamic]),
|
||||
isListT: dart.definiteFunctionType(core.bool, [dart.dynamic])
|
||||
})
|
||||
});
|
||||
return Foo;
|
||||
});
|
||||
generic_instanceof_test.Foo = Foo();
|
||||
generic_instanceof_test.GenericInstanceof = class GenericInstanceof extends core.Object {
|
||||
static testMain() {
|
||||
let fooObject = new (FooOfString())();
|
||||
expect$.Expect.equals(true, fooObject.isT("string"));
|
||||
expect$.Expect.equals(false, fooObject.isT(1));
|
||||
let fooString = new (FooOfString())();
|
||||
expect$.Expect.equals(true, fooString.isT("string"));
|
||||
expect$.Expect.equals(false, fooString.isT(1));
|
||||
{
|
||||
let foo = new (FooOfString())();
|
||||
expect$.Expect.equals(true, foo.isT("string"));
|
||||
expect$.Expect.equals(false, foo.isT(1));
|
||||
}
|
||||
{
|
||||
let foo = new generic_instanceof_test.Foo();
|
||||
expect$.Expect.equals(true, foo.isT(core.List.new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfList())();
|
||||
expect$.Expect.equals(true, foo.isT(core.List.new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfListOfObject())();
|
||||
expect$.Expect.equals(true, foo.isT(core.List.new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfListOfint())();
|
||||
expect$.Expect.equals(true, foo.isT(core.List.new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfListOfnum())();
|
||||
expect$.Expect.equals(true, foo.isT(core.List.new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfListOfString())();
|
||||
expect$.Expect.equals(true, foo.isT(core.List.new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new generic_instanceof_test.Foo();
|
||||
expect$.Expect.equals(true, foo.isListT(core.List.new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfObject())();
|
||||
expect$.Expect.equals(true, foo.isListT(core.List.new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfint())();
|
||||
expect$.Expect.equals(true, foo.isListT(core.List.new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfnum())();
|
||||
expect$.Expect.equals(true, foo.isListT(core.List.new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfString())();
|
||||
expect$.Expect.equals(true, foo.isListT(core.List.new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfString().new(5)));
|
||||
}
|
||||
}
|
||||
};
|
||||
dart.setSignature(generic_instanceof_test.GenericInstanceof, {
|
||||
statics: () => ({testMain: dart.definiteFunctionType(dart.void, [])}),
|
||||
names: ['testMain']
|
||||
});
|
||||
// Exports:
|
||||
exports.generic_instanceof_test = generic_instanceof_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,38 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/hello_script_test', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'expect'
|
||||
], function load__hello_script_test(exports, dart_sdk, expect) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect$ = expect.expect;
|
||||
const hello_script_test = Object.create(null);
|
||||
const hello_script_lib = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
hello_script_test.main = function() {
|
||||
hello_script_lib.HelloLib.doTest();
|
||||
expect$.Expect.equals(18, hello_script_lib.x);
|
||||
core.print("Hello done.");
|
||||
};
|
||||
dart.fn(hello_script_test.main, VoidTodynamic());
|
||||
hello_script_lib.HelloLib = class HelloLib extends core.Object {
|
||||
static doTest() {
|
||||
hello_script_lib.x = 17;
|
||||
expect$.Expect.equals(17, (() => {
|
||||
let x = hello_script_lib.x;
|
||||
hello_script_lib.x = dart.dsend(x, '+', 1);
|
||||
return x;
|
||||
})());
|
||||
core.print("Hello from Lib!");
|
||||
}
|
||||
};
|
||||
dart.setSignature(hello_script_lib.HelloLib, {
|
||||
statics: () => ({doTest: dart.definiteFunctionType(dart.dynamic, [])}),
|
||||
names: ['doTest']
|
||||
});
|
||||
hello_script_lib.x = null;
|
||||
// Exports:
|
||||
exports.hello_script_test = hello_script_test;
|
||||
exports.hello_script_lib = hello_script_lib;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,43 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/inline_super_test', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'expect'
|
||||
], function load__inline_super_test(exports, dart_sdk, expect) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect$ = expect.expect;
|
||||
const inline_super_test = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
inline_super_test.Percept = class Percept extends core.Object {};
|
||||
inline_super_test.Actor = class Actor extends core.Object {
|
||||
new(percept) {
|
||||
this.percept = percept;
|
||||
}
|
||||
};
|
||||
dart.setSignature(inline_super_test.Actor, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(inline_super_test.Actor, [dart.dynamic])})
|
||||
});
|
||||
inline_super_test.LivingActor = class LivingActor extends inline_super_test.Actor {
|
||||
new() {
|
||||
super.new(new inline_super_test.Percept());
|
||||
}
|
||||
};
|
||||
dart.setSignature(inline_super_test.LivingActor, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(inline_super_test.LivingActor, [])})
|
||||
});
|
||||
inline_super_test.main = function() {
|
||||
expect$.Expect.isTrue(inline_super_test.Percept.is(new inline_super_test.Player().percept));
|
||||
};
|
||||
dart.fn(inline_super_test.main, VoidTodynamic());
|
||||
inline_super_test.Player = class Player extends inline_super_test.LivingActor {
|
||||
new() {
|
||||
super.new();
|
||||
}
|
||||
};
|
||||
dart.setSignature(inline_super_test.Player, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(inline_super_test.Player, [])})
|
||||
});
|
||||
// Exports:
|
||||
exports.inline_super_test = inline_super_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,27 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/lazy_static6_test', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'expect'
|
||||
], function load__lazy_static6_test(exports, dart_sdk, expect) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect$ = expect.expect;
|
||||
const lazy_static6_test = Object.create(null);
|
||||
let dynamicTodynamic = () => (dynamicTodynamic = dart.constFn(dart.functionType(dart.dynamic, [dart.dynamic])))();
|
||||
let dynamicTodynamic$ = () => (dynamicTodynamic$ = dart.constFn(dart.definiteFunctionType(dart.dynamic, [dart.dynamic])))();
|
||||
let dynamicToFn = () => (dynamicToFn = dart.constFn(dart.definiteFunctionType(dynamicTodynamic(), [dart.dynamic])))();
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
dart.defineLazy(lazy_static6_test, {
|
||||
get x() {
|
||||
return dart.fn(t => dart.fn(u => dart.dsend(t, '+', u), dynamicTodynamic$()), dynamicToFn());
|
||||
}
|
||||
});
|
||||
lazy_static6_test.main = function() {
|
||||
expect$.Expect.equals(499, dart.dcall(dart.dcall(lazy_static6_test.x, 498), 1));
|
||||
expect$.Expect.equals(42, dart.dcall(dart.dcall(lazy_static6_test.x, 39), 3));
|
||||
};
|
||||
dart.fn(lazy_static6_test.main, VoidTodynamic());
|
||||
// Exports:
|
||||
exports.lazy_static6_test = lazy_static6_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,42 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/library1_test', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'expect'
|
||||
], function load__library1_test(exports, dart_sdk, expect) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect$ = expect.expect;
|
||||
const library1_test = Object.create(null);
|
||||
const library1_lib = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
library1_test.main = function() {
|
||||
library1_test.Library1Test.testMain();
|
||||
};
|
||||
dart.fn(library1_test.main, VoidTodynamic());
|
||||
library1_test.Library1Test = class Library1Test extends core.Object {
|
||||
static testMain() {
|
||||
let a = new library1_lib.A();
|
||||
let s = a.foo();
|
||||
expect$.Expect.equals(s, "foo-rty two");
|
||||
}
|
||||
};
|
||||
dart.setSignature(library1_test.Library1Test, {
|
||||
statics: () => ({testMain: dart.definiteFunctionType(dart.dynamic, [])}),
|
||||
names: ['testMain']
|
||||
});
|
||||
library1_lib.A = class A extends core.Object {
|
||||
new() {
|
||||
}
|
||||
foo() {
|
||||
return "foo-rty two";
|
||||
}
|
||||
};
|
||||
dart.setSignature(library1_lib.A, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(library1_lib.A, [])}),
|
||||
methods: () => ({foo: dart.definiteFunctionType(core.String, [])})
|
||||
});
|
||||
// Exports:
|
||||
exports.library1_test = library1_test;
|
||||
exports.library1_lib = library1_lib;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,22 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/library_juxtaposition_test', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'expect'
|
||||
], function load__library_juxtaposition_test(exports, dart_sdk, expect) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect$ = expect.expect;
|
||||
const library_juxtaposition_test = Object.create(null);
|
||||
const library_juxtaposition_lib = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
library_juxtaposition_test.main = function() {
|
||||
expect$.Expect.equals(library_juxtaposition_lib.c, 47);
|
||||
};
|
||||
dart.fn(library_juxtaposition_test.main, VoidTodynamic());
|
||||
library_juxtaposition_lib.c = 47;
|
||||
library_juxtaposition_test.c = library_juxtaposition_lib.c;
|
||||
// Exports:
|
||||
exports.library_juxtaposition_test = library_juxtaposition_test;
|
||||
exports.library_juxtaposition_lib = library_juxtaposition_lib;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,350 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/library_prefixes_test', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'expect'
|
||||
], function load__library_prefixes_test(exports, dart_sdk, expect) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect$ = expect.expect;
|
||||
const library_prefixes_test = Object.create(null);
|
||||
const library_prefixes = Object.create(null);
|
||||
const library_prefixes_test1 = Object.create(null);
|
||||
const library_prefixes_test2 = Object.create(null);
|
||||
let dynamicAnddynamicTodynamic = () => (dynamicAnddynamicTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [dart.dynamic, dart.dynamic])))();
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
library_prefixes_test.LibraryPrefixesTest = class LibraryPrefixesTest extends core.Object {
|
||||
static testMain() {
|
||||
library_prefixes.LibraryPrefixes.main(dart.fn((a, b) => {
|
||||
expect$.Expect.equals(a, b);
|
||||
}, dynamicAnddynamicTodynamic()));
|
||||
}
|
||||
};
|
||||
dart.setSignature(library_prefixes_test.LibraryPrefixesTest, {
|
||||
statics: () => ({testMain: dart.definiteFunctionType(dart.dynamic, [])}),
|
||||
names: ['testMain']
|
||||
});
|
||||
library_prefixes_test.main = function() {
|
||||
library_prefixes_test.LibraryPrefixesTest.testMain();
|
||||
};
|
||||
dart.fn(library_prefixes_test.main, VoidTodynamic());
|
||||
let const$;
|
||||
let const$0;
|
||||
let const$1;
|
||||
let const$2;
|
||||
let const$3;
|
||||
let const$4;
|
||||
let const$5;
|
||||
let const$6;
|
||||
library_prefixes.LibraryPrefixes = class LibraryPrefixes extends core.Object {
|
||||
static main(expectEquals) {
|
||||
let a = library_prefixes_test1.Constants.PI;
|
||||
let b = library_prefixes_test2.Constants.PI;
|
||||
dart.dcall(expectEquals, 3.14, a);
|
||||
dart.dcall(expectEquals, 3.14, b);
|
||||
dart.dcall(expectEquals, 1, library_prefixes_test1.Constants.foo);
|
||||
dart.dcall(expectEquals, 2, library_prefixes_test2.Constants.foo);
|
||||
dart.dcall(expectEquals, -1, library_prefixes_test1.A.y);
|
||||
dart.dcall(expectEquals, 0, library_prefixes_test2.A.y);
|
||||
dart.dcall(expectEquals, 1, new library_prefixes_test1.A().x);
|
||||
dart.dcall(expectEquals, 2, new library_prefixes_test2.A().x);
|
||||
dart.dcall(expectEquals, 3, new library_prefixes_test1.A.named().x);
|
||||
dart.dcall(expectEquals, 4, new library_prefixes_test2.A.named().x);
|
||||
dart.dcall(expectEquals, 3, library_prefixes_test1.A.fac().x);
|
||||
dart.dcall(expectEquals, 4, library_prefixes_test2.A.fac().x);
|
||||
dart.dcall(expectEquals, 1, new library_prefixes_test1.B().x);
|
||||
dart.dcall(expectEquals, 2, new library_prefixes_test2.B().x);
|
||||
dart.dcall(expectEquals, 8, new library_prefixes_test1.B.named().x);
|
||||
dart.dcall(expectEquals, 13, new library_prefixes_test2.B.named().x);
|
||||
dart.dcall(expectEquals, 8, library_prefixes_test1.B.fac().x);
|
||||
dart.dcall(expectEquals, 13, library_prefixes_test2.B.fac().x);
|
||||
dart.dcall(expectEquals, 1, (const$ || (const$ = dart.const(new library_prefixes_test1.C()))).x);
|
||||
dart.dcall(expectEquals, 2, (const$0 || (const$0 = dart.const(new library_prefixes_test2.C()))).x);
|
||||
dart.dcall(expectEquals, 3, (const$1 || (const$1 = dart.const(new library_prefixes_test1.C.named()))).x);
|
||||
dart.dcall(expectEquals, 4, (const$2 || (const$2 = dart.const(new library_prefixes_test2.C.named()))).x);
|
||||
dart.dcall(expectEquals, 3, library_prefixes_test1.C.fac().x);
|
||||
dart.dcall(expectEquals, 4, library_prefixes_test2.C.fac().x);
|
||||
dart.dcall(expectEquals, 1, (const$3 || (const$3 = dart.const(new library_prefixes_test1.D()))).x);
|
||||
dart.dcall(expectEquals, 2, (const$4 || (const$4 = dart.const(new library_prefixes_test2.D()))).x);
|
||||
dart.dcall(expectEquals, 8, (const$5 || (const$5 = dart.const(new library_prefixes_test1.D.named()))).x);
|
||||
dart.dcall(expectEquals, 13, (const$6 || (const$6 = dart.const(new library_prefixes_test2.D.named()))).x);
|
||||
dart.dcall(expectEquals, 8, library_prefixes_test1.D.fac().x);
|
||||
dart.dcall(expectEquals, 13, library_prefixes_test2.D.fac().x);
|
||||
dart.dcall(expectEquals, 0, library_prefixes_test1.E.foo());
|
||||
dart.dcall(expectEquals, 3, library_prefixes_test2.E.foo());
|
||||
dart.dcall(expectEquals, 1, new library_prefixes_test1.E().bar());
|
||||
dart.dcall(expectEquals, 4, new library_prefixes_test2.E().bar());
|
||||
dart.dcall(expectEquals, 9, dart.dcall(new library_prefixes_test1.E().toto(7)));
|
||||
dart.dcall(expectEquals, 16, dart.dcall(new library_prefixes_test2.E().toto(11)));
|
||||
dart.dcall(expectEquals, 111, dart.dcall(new library_prefixes_test1.E.fun(100).f));
|
||||
dart.dcall(expectEquals, 1313, dart.dcall(new library_prefixes_test2.E.fun(1300).f));
|
||||
dart.dcall(expectEquals, 999, dart.dcall(library_prefixes_test1.E.fooo(900)));
|
||||
dart.dcall(expectEquals, 2048, dart.dcall(library_prefixes_test2.E.fooo(1024)));
|
||||
}
|
||||
};
|
||||
dart.setSignature(library_prefixes.LibraryPrefixes, {
|
||||
statics: () => ({main: dart.definiteFunctionType(dart.void, [dart.dynamic])}),
|
||||
names: ['main']
|
||||
});
|
||||
library_prefixes_test1.Constants = class Constants extends core.Object {};
|
||||
library_prefixes_test1.Constants.PI = 3.14;
|
||||
library_prefixes_test1.Constants.foo = 1;
|
||||
library_prefixes_test1.A = class A extends core.Object {
|
||||
new() {
|
||||
this.x = 1;
|
||||
}
|
||||
named() {
|
||||
this.x = 3;
|
||||
}
|
||||
superC(x) {
|
||||
this.x = core.int._check(dart.dsend(x, '+', 7));
|
||||
}
|
||||
static fac() {
|
||||
return new library_prefixes_test1.A.named();
|
||||
}
|
||||
};
|
||||
dart.defineNamedConstructor(library_prefixes_test1.A, 'named');
|
||||
dart.defineNamedConstructor(library_prefixes_test1.A, 'superC');
|
||||
dart.setSignature(library_prefixes_test1.A, {
|
||||
constructors: () => ({
|
||||
new: dart.definiteFunctionType(library_prefixes_test1.A, []),
|
||||
named: dart.definiteFunctionType(library_prefixes_test1.A, []),
|
||||
superC: dart.definiteFunctionType(library_prefixes_test1.A, [dart.dynamic]),
|
||||
fac: dart.definiteFunctionType(library_prefixes_test1.A, [])
|
||||
})
|
||||
});
|
||||
library_prefixes_test1.A.y = -1;
|
||||
library_prefixes_test1.B = class B extends library_prefixes_test1.A {
|
||||
new() {
|
||||
super.new();
|
||||
}
|
||||
named() {
|
||||
super.superC(1);
|
||||
}
|
||||
static fac() {
|
||||
return new library_prefixes_test1.B.named();
|
||||
}
|
||||
};
|
||||
dart.defineNamedConstructor(library_prefixes_test1.B, 'named');
|
||||
dart.setSignature(library_prefixes_test1.B, {
|
||||
constructors: () => ({
|
||||
new: dart.definiteFunctionType(library_prefixes_test1.B, []),
|
||||
named: dart.definiteFunctionType(library_prefixes_test1.B, []),
|
||||
fac: dart.definiteFunctionType(library_prefixes_test1.B, [])
|
||||
})
|
||||
});
|
||||
let const$7;
|
||||
library_prefixes_test1.C = class C extends core.Object {
|
||||
new() {
|
||||
this.x = 1;
|
||||
}
|
||||
named() {
|
||||
this.x = 3;
|
||||
}
|
||||
superC(x) {
|
||||
this.x = core.int._check(dart.dsend(x, '+', 7));
|
||||
}
|
||||
static fac() {
|
||||
return const$7 || (const$7 = dart.const(new library_prefixes_test1.C.named()));
|
||||
}
|
||||
};
|
||||
dart.defineNamedConstructor(library_prefixes_test1.C, 'named');
|
||||
dart.defineNamedConstructor(library_prefixes_test1.C, 'superC');
|
||||
dart.setSignature(library_prefixes_test1.C, {
|
||||
constructors: () => ({
|
||||
new: dart.definiteFunctionType(library_prefixes_test1.C, []),
|
||||
named: dart.definiteFunctionType(library_prefixes_test1.C, []),
|
||||
superC: dart.definiteFunctionType(library_prefixes_test1.C, [dart.dynamic]),
|
||||
fac: dart.definiteFunctionType(library_prefixes_test1.C, [])
|
||||
})
|
||||
});
|
||||
let const$8;
|
||||
library_prefixes_test1.D = class D extends library_prefixes_test1.C {
|
||||
new() {
|
||||
super.new();
|
||||
}
|
||||
named() {
|
||||
super.superC(1);
|
||||
}
|
||||
static fac() {
|
||||
return const$8 || (const$8 = dart.const(new library_prefixes_test1.D.named()));
|
||||
}
|
||||
};
|
||||
dart.defineNamedConstructor(library_prefixes_test1.D, 'named');
|
||||
dart.setSignature(library_prefixes_test1.D, {
|
||||
constructors: () => ({
|
||||
new: dart.definiteFunctionType(library_prefixes_test1.D, []),
|
||||
named: dart.definiteFunctionType(library_prefixes_test1.D, []),
|
||||
fac: dart.definiteFunctionType(library_prefixes_test1.D, [])
|
||||
})
|
||||
});
|
||||
library_prefixes_test1.E = class E extends core.Object {
|
||||
new() {
|
||||
this.f = null;
|
||||
}
|
||||
fun(x) {
|
||||
this.f = dart.fn(() => dart.dsend(x, '+', 11), VoidTodynamic());
|
||||
}
|
||||
static foo() {
|
||||
return 0;
|
||||
}
|
||||
static fooo(x) {
|
||||
return dart.fn(() => dart.dsend(x, '+', 99), VoidTodynamic());
|
||||
}
|
||||
bar() {
|
||||
return 1;
|
||||
}
|
||||
toto(x) {
|
||||
return dart.fn(() => dart.dsend(x, '+', 2), VoidTodynamic());
|
||||
}
|
||||
};
|
||||
dart.defineNamedConstructor(library_prefixes_test1.E, 'fun');
|
||||
dart.setSignature(library_prefixes_test1.E, {
|
||||
constructors: () => ({
|
||||
new: dart.definiteFunctionType(library_prefixes_test1.E, []),
|
||||
fun: dart.definiteFunctionType(library_prefixes_test1.E, [dart.dynamic])
|
||||
}),
|
||||
methods: () => ({
|
||||
bar: dart.definiteFunctionType(dart.dynamic, []),
|
||||
toto: dart.definiteFunctionType(dart.dynamic, [dart.dynamic])
|
||||
}),
|
||||
statics: () => ({
|
||||
foo: dart.definiteFunctionType(dart.dynamic, []),
|
||||
fooo: dart.definiteFunctionType(dart.dynamic, [dart.dynamic])
|
||||
}),
|
||||
names: ['foo', 'fooo']
|
||||
});
|
||||
library_prefixes_test2.Constants = class Constants extends core.Object {};
|
||||
library_prefixes_test2.Constants.PI = 3.14;
|
||||
library_prefixes_test2.Constants.foo = 2;
|
||||
library_prefixes_test2.A = class A extends core.Object {
|
||||
new() {
|
||||
this.x = 2;
|
||||
}
|
||||
named() {
|
||||
this.x = 4;
|
||||
}
|
||||
superC(x) {
|
||||
this.x = core.int._check(dart.dsend(x, '+', 11));
|
||||
}
|
||||
static fac() {
|
||||
return new library_prefixes_test2.A.named();
|
||||
}
|
||||
};
|
||||
dart.defineNamedConstructor(library_prefixes_test2.A, 'named');
|
||||
dart.defineNamedConstructor(library_prefixes_test2.A, 'superC');
|
||||
dart.setSignature(library_prefixes_test2.A, {
|
||||
constructors: () => ({
|
||||
new: dart.definiteFunctionType(library_prefixes_test2.A, []),
|
||||
named: dart.definiteFunctionType(library_prefixes_test2.A, []),
|
||||
superC: dart.definiteFunctionType(library_prefixes_test2.A, [dart.dynamic]),
|
||||
fac: dart.definiteFunctionType(library_prefixes_test2.A, [])
|
||||
})
|
||||
});
|
||||
library_prefixes_test2.A.y = 0;
|
||||
library_prefixes_test2.B = class B extends library_prefixes_test2.A {
|
||||
new() {
|
||||
super.new();
|
||||
}
|
||||
named() {
|
||||
super.superC(2);
|
||||
}
|
||||
static fac() {
|
||||
return new library_prefixes_test2.B.named();
|
||||
}
|
||||
};
|
||||
dart.defineNamedConstructor(library_prefixes_test2.B, 'named');
|
||||
dart.setSignature(library_prefixes_test2.B, {
|
||||
constructors: () => ({
|
||||
new: dart.definiteFunctionType(library_prefixes_test2.B, []),
|
||||
named: dart.definiteFunctionType(library_prefixes_test2.B, []),
|
||||
fac: dart.definiteFunctionType(library_prefixes_test2.B, [])
|
||||
})
|
||||
});
|
||||
let const$9;
|
||||
library_prefixes_test2.C = class C extends core.Object {
|
||||
new() {
|
||||
this.x = 2;
|
||||
}
|
||||
named() {
|
||||
this.x = 4;
|
||||
}
|
||||
superC(x) {
|
||||
this.x = core.int._check(dart.dsend(x, '+', 11));
|
||||
}
|
||||
static fac() {
|
||||
return const$9 || (const$9 = dart.const(new library_prefixes_test2.C.named()));
|
||||
}
|
||||
};
|
||||
dart.defineNamedConstructor(library_prefixes_test2.C, 'named');
|
||||
dart.defineNamedConstructor(library_prefixes_test2.C, 'superC');
|
||||
dart.setSignature(library_prefixes_test2.C, {
|
||||
constructors: () => ({
|
||||
new: dart.definiteFunctionType(library_prefixes_test2.C, []),
|
||||
named: dart.definiteFunctionType(library_prefixes_test2.C, []),
|
||||
superC: dart.definiteFunctionType(library_prefixes_test2.C, [dart.dynamic]),
|
||||
fac: dart.definiteFunctionType(library_prefixes_test2.C, [])
|
||||
})
|
||||
});
|
||||
let const$10;
|
||||
library_prefixes_test2.D = class D extends library_prefixes_test2.C {
|
||||
new() {
|
||||
super.new();
|
||||
}
|
||||
named() {
|
||||
super.superC(2);
|
||||
}
|
||||
static fac() {
|
||||
return const$10 || (const$10 = dart.const(new library_prefixes_test2.D.named()));
|
||||
}
|
||||
};
|
||||
dart.defineNamedConstructor(library_prefixes_test2.D, 'named');
|
||||
dart.setSignature(library_prefixes_test2.D, {
|
||||
constructors: () => ({
|
||||
new: dart.definiteFunctionType(library_prefixes_test2.D, []),
|
||||
named: dart.definiteFunctionType(library_prefixes_test2.D, []),
|
||||
fac: dart.definiteFunctionType(library_prefixes_test2.D, [])
|
||||
})
|
||||
});
|
||||
library_prefixes_test2.E = class E extends core.Object {
|
||||
new() {
|
||||
this.f = null;
|
||||
}
|
||||
fun(x) {
|
||||
this.f = dart.fn(() => dart.dsend(x, '+', 13), VoidTodynamic());
|
||||
}
|
||||
static foo() {
|
||||
return 3;
|
||||
}
|
||||
static fooo(x) {
|
||||
return dart.fn(() => dart.dsend(x, '+', 1024), VoidTodynamic());
|
||||
}
|
||||
bar() {
|
||||
return 4;
|
||||
}
|
||||
toto(x) {
|
||||
return dart.fn(() => dart.dsend(x, '+', 5), VoidTodynamic());
|
||||
}
|
||||
};
|
||||
dart.defineNamedConstructor(library_prefixes_test2.E, 'fun');
|
||||
dart.setSignature(library_prefixes_test2.E, {
|
||||
constructors: () => ({
|
||||
new: dart.definiteFunctionType(library_prefixes_test2.E, []),
|
||||
fun: dart.definiteFunctionType(library_prefixes_test2.E, [dart.dynamic])
|
||||
}),
|
||||
methods: () => ({
|
||||
bar: dart.definiteFunctionType(dart.dynamic, []),
|
||||
toto: dart.definiteFunctionType(dart.dynamic, [dart.dynamic])
|
||||
}),
|
||||
statics: () => ({
|
||||
foo: dart.definiteFunctionType(dart.dynamic, []),
|
||||
fooo: dart.definiteFunctionType(dart.dynamic, [dart.dynamic])
|
||||
}),
|
||||
names: ['foo', 'fooo']
|
||||
});
|
||||
// Exports:
|
||||
exports.library_prefixes_test = library_prefixes_test;
|
||||
exports.library_prefixes = library_prefixes;
|
||||
exports.library_prefixes_test1 = library_prefixes_test1;
|
||||
exports.library_prefixes_test2 = library_prefixes_test2;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,173 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/many_generic_instanceof_test', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'expect'
|
||||
], function load__many_generic_instanceof_test(exports, dart_sdk, expect) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect$ = expect.expect;
|
||||
const many_generic_instanceof_test = Object.create(null);
|
||||
let Foo = () => (Foo = dart.constFn(many_generic_instanceof_test.Foo$()))();
|
||||
let FooOfString = () => (FooOfString = dart.constFn(many_generic_instanceof_test.Foo$(core.String)))();
|
||||
let ListOfObject = () => (ListOfObject = dart.constFn(core.List$(core.Object)))();
|
||||
let ListOfint = () => (ListOfint = dart.constFn(core.List$(core.int)))();
|
||||
let ListOfnum = () => (ListOfnum = dart.constFn(core.List$(core.num)))();
|
||||
let ListOfString = () => (ListOfString = dart.constFn(core.List$(core.String)))();
|
||||
let FooOfList = () => (FooOfList = dart.constFn(many_generic_instanceof_test.Foo$(core.List)))();
|
||||
let FooOfListOfObject = () => (FooOfListOfObject = dart.constFn(many_generic_instanceof_test.Foo$(ListOfObject())))();
|
||||
let FooOfListOfint = () => (FooOfListOfint = dart.constFn(many_generic_instanceof_test.Foo$(ListOfint())))();
|
||||
let FooOfListOfnum = () => (FooOfListOfnum = dart.constFn(many_generic_instanceof_test.Foo$(ListOfnum())))();
|
||||
let FooOfListOfString = () => (FooOfListOfString = dart.constFn(many_generic_instanceof_test.Foo$(ListOfString())))();
|
||||
let FooOfObject = () => (FooOfObject = dart.constFn(many_generic_instanceof_test.Foo$(core.Object)))();
|
||||
let FooOfint = () => (FooOfint = dart.constFn(many_generic_instanceof_test.Foo$(core.int)))();
|
||||
let FooOfnum = () => (FooOfnum = dart.constFn(many_generic_instanceof_test.Foo$(core.num)))();
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
many_generic_instanceof_test.ManyGenericInstanceofTest = class ManyGenericInstanceofTest extends core.Object {
|
||||
static testMain() {
|
||||
for (let i = 0; i < 20; i++) {
|
||||
many_generic_instanceof_test.GenericInstanceof.testMain();
|
||||
}
|
||||
}
|
||||
};
|
||||
dart.setSignature(many_generic_instanceof_test.ManyGenericInstanceofTest, {
|
||||
statics: () => ({testMain: dart.definiteFunctionType(dart.dynamic, [])}),
|
||||
names: ['testMain']
|
||||
});
|
||||
many_generic_instanceof_test.main = function() {
|
||||
many_generic_instanceof_test.ManyGenericInstanceofTest.testMain();
|
||||
};
|
||||
dart.fn(many_generic_instanceof_test.main, VoidTodynamic());
|
||||
many_generic_instanceof_test.Foo$ = dart.generic(T => {
|
||||
let ListOfT = () => (ListOfT = dart.constFn(core.List$(T)))();
|
||||
class Foo extends core.Object {
|
||||
new() {
|
||||
}
|
||||
isT(x) {
|
||||
return T.is(x);
|
||||
}
|
||||
isListT(x) {
|
||||
return ListOfT().is(x);
|
||||
}
|
||||
}
|
||||
dart.addTypeTests(Foo);
|
||||
dart.setSignature(Foo, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(many_generic_instanceof_test.Foo$(T), [])}),
|
||||
methods: () => ({
|
||||
isT: dart.definiteFunctionType(core.bool, [dart.dynamic]),
|
||||
isListT: dart.definiteFunctionType(core.bool, [dart.dynamic])
|
||||
})
|
||||
});
|
||||
return Foo;
|
||||
});
|
||||
many_generic_instanceof_test.Foo = Foo();
|
||||
many_generic_instanceof_test.GenericInstanceof = class GenericInstanceof extends core.Object {
|
||||
static testMain() {
|
||||
let fooObject = new (FooOfString())();
|
||||
expect$.Expect.equals(true, fooObject.isT("string"));
|
||||
expect$.Expect.equals(false, fooObject.isT(1));
|
||||
let fooString = new (FooOfString())();
|
||||
expect$.Expect.equals(true, fooString.isT("string"));
|
||||
expect$.Expect.equals(false, fooString.isT(1));
|
||||
{
|
||||
let foo = new (FooOfString())();
|
||||
expect$.Expect.equals(true, foo.isT("string"));
|
||||
expect$.Expect.equals(false, foo.isT(1));
|
||||
}
|
||||
{
|
||||
let foo = new many_generic_instanceof_test.Foo();
|
||||
expect$.Expect.equals(true, foo.isT(core.List.new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfList())();
|
||||
expect$.Expect.equals(true, foo.isT(core.List.new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfListOfObject())();
|
||||
expect$.Expect.equals(true, foo.isT(core.List.new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfListOfint())();
|
||||
expect$.Expect.equals(true, foo.isT(core.List.new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfListOfnum())();
|
||||
expect$.Expect.equals(true, foo.isT(core.List.new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfListOfString())();
|
||||
expect$.Expect.equals(true, foo.isT(core.List.new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(false, foo.isT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new many_generic_instanceof_test.Foo();
|
||||
expect$.Expect.equals(true, foo.isListT(core.List.new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfObject())();
|
||||
expect$.Expect.equals(true, foo.isListT(core.List.new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfint())();
|
||||
expect$.Expect.equals(true, foo.isListT(core.List.new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfnum())();
|
||||
expect$.Expect.equals(true, foo.isListT(core.List.new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfString().new(5)));
|
||||
}
|
||||
{
|
||||
let foo = new (FooOfString())();
|
||||
expect$.Expect.equals(true, foo.isListT(core.List.new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfObject().new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfint().new(5)));
|
||||
expect$.Expect.equals(false, foo.isListT(ListOfnum().new(5)));
|
||||
expect$.Expect.equals(true, foo.isListT(ListOfString().new(5)));
|
||||
}
|
||||
}
|
||||
};
|
||||
dart.setSignature(many_generic_instanceof_test.GenericInstanceof, {
|
||||
statics: () => ({testMain: dart.definiteFunctionType(dart.void, [])}),
|
||||
names: ['testMain']
|
||||
});
|
||||
// Exports:
|
||||
exports.many_generic_instanceof_test = many_generic_instanceof_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,52 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/multi_pass2_test', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'expect'
|
||||
], function load__multi_pass2_test(exports, dart_sdk, expect) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect$ = expect.expect;
|
||||
const multi_pass2_test = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
multi_pass2_test.Base = class Base extends core.Object {
|
||||
new(value) {
|
||||
this.value = value;
|
||||
}
|
||||
};
|
||||
dart.setSignature(multi_pass2_test.Base, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(multi_pass2_test.Base, [dart.dynamic])})
|
||||
});
|
||||
multi_pass2_test.MultiPass2Test = class MultiPass2Test extends core.Object {
|
||||
static testMain() {
|
||||
let a = new multi_pass2_test.B(5);
|
||||
expect$.Expect.equals(5, a.value);
|
||||
}
|
||||
};
|
||||
dart.setSignature(multi_pass2_test.MultiPass2Test, {
|
||||
statics: () => ({testMain: dart.definiteFunctionType(dart.dynamic, [])}),
|
||||
names: ['testMain']
|
||||
});
|
||||
multi_pass2_test.main = function() {
|
||||
multi_pass2_test.MultiPass2Test.testMain();
|
||||
};
|
||||
dart.fn(multi_pass2_test.main, VoidTodynamic());
|
||||
multi_pass2_test.A = class A extends multi_pass2_test.Base {
|
||||
new(v) {
|
||||
super.new(v);
|
||||
}
|
||||
};
|
||||
dart.setSignature(multi_pass2_test.A, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(multi_pass2_test.A, [dart.dynamic])})
|
||||
});
|
||||
multi_pass2_test.B = class B extends multi_pass2_test.A {
|
||||
new(v) {
|
||||
super.new(v);
|
||||
}
|
||||
};
|
||||
dart.setSignature(multi_pass2_test.B, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(multi_pass2_test.B, [dart.dynamic])})
|
||||
});
|
||||
// Exports:
|
||||
exports.multi_pass2_test = multi_pass2_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,52 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/multi_pass_test', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'expect'
|
||||
], function load__multi_pass_test(exports, dart_sdk, expect) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect$ = expect.expect;
|
||||
const multi_pass_test = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
multi_pass_test.Base = class Base extends core.Object {
|
||||
new(value) {
|
||||
this.value = value;
|
||||
}
|
||||
};
|
||||
dart.setSignature(multi_pass_test.Base, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(multi_pass_test.Base, [dart.dynamic])})
|
||||
});
|
||||
multi_pass_test.MultiPassTest = class MultiPassTest extends core.Object {
|
||||
static testMain() {
|
||||
let a = new multi_pass_test.B(5);
|
||||
expect$.Expect.equals(5, a.value);
|
||||
}
|
||||
};
|
||||
dart.setSignature(multi_pass_test.MultiPassTest, {
|
||||
statics: () => ({testMain: dart.definiteFunctionType(dart.dynamic, [])}),
|
||||
names: ['testMain']
|
||||
});
|
||||
multi_pass_test.main = function() {
|
||||
multi_pass_test.MultiPassTest.testMain();
|
||||
};
|
||||
dart.fn(multi_pass_test.main, VoidTodynamic());
|
||||
multi_pass_test.A = class A extends multi_pass_test.Base {
|
||||
new(v) {
|
||||
super.new(v);
|
||||
}
|
||||
};
|
||||
dart.setSignature(multi_pass_test.A, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(multi_pass_test.A, [dart.dynamic])})
|
||||
});
|
||||
multi_pass_test.B = class B extends multi_pass_test.A {
|
||||
new(v) {
|
||||
super.new(v);
|
||||
}
|
||||
};
|
||||
dart.setSignature(multi_pass_test.B, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(multi_pass_test.B, [dart.dynamic])})
|
||||
});
|
||||
// Exports:
|
||||
exports.multi_pass_test = multi_pass_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,17 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/part_test', null, /* Imports */[
|
||||
'dart_sdk'
|
||||
], function load__part_test(exports, dart_sdk) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const part_test = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
part_test.main = function() {
|
||||
core.print(part_test.foo);
|
||||
};
|
||||
dart.fn(part_test.main, VoidTodynamic());
|
||||
part_test.foo = 'foo';
|
||||
// Exports:
|
||||
exports.part_test = part_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,49 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/private2_test', null, /* Imports */[
|
||||
'dart_sdk'
|
||||
], function load__private2_test(exports, dart_sdk) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const private2_test = Object.create(null);
|
||||
const private2_lib = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
const _f = Symbol('_f');
|
||||
private2_test.A = class A extends core.Object {
|
||||
new() {
|
||||
this[_f] = 42;
|
||||
this.g = 43;
|
||||
}
|
||||
};
|
||||
dart.setSignature(private2_test.A, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(private2_test.A, [])})
|
||||
});
|
||||
private2_lib.B = class B extends private2_test.A {
|
||||
new() {
|
||||
super.new();
|
||||
}
|
||||
};
|
||||
dart.setSignature(private2_lib.B, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(private2_lib.B, [])})
|
||||
});
|
||||
private2_test.C = class C extends private2_lib.B {
|
||||
new() {
|
||||
super.new();
|
||||
}
|
||||
};
|
||||
dart.setSignature(private2_test.C, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(private2_test.C, [])})
|
||||
});
|
||||
private2_test.main = function() {
|
||||
let a = new private2_test.A();
|
||||
core.print(a.g);
|
||||
core.print(a[_f]);
|
||||
let o = new private2_test.C();
|
||||
core.print(o.g);
|
||||
core.print(o[_f]);
|
||||
};
|
||||
dart.fn(private2_test.main, VoidTodynamic());
|
||||
// Exports:
|
||||
exports.private2_test = private2_test;
|
||||
exports.private2_lib = private2_lib;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,17 +1 @@
|
|||
dart_library.library('language/regress_18535_test', null, /* Imports */[
|
||||
'dart_sdk'
|
||||
], function load__regress_18535_test(exports, dart_sdk) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const mirrors = dart_sdk.mirrors;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const regress_18535_test = Object.create(null);
|
||||
let VoidTovoid = () => (VoidTovoid = dart.constFn(dart.definiteFunctionType(dart.void, [])))();
|
||||
regress_18535_test.main = function() {
|
||||
core.print(mirrors.currentMirrorSystem().libraries);
|
||||
};
|
||||
dart.fn(regress_18535_test.main, VoidTovoid());
|
||||
// Exports:
|
||||
exports.regress_18535_test = regress_18535_test;
|
||||
});
|
||||
//FAILED TO COMPILE
|
||||
|
|
@ -1 +1,15 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/top_level_entry_test', null, /* Imports */[
|
||||
'dart_sdk'
|
||||
], function load__top_level_entry_test(exports, dart_sdk) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const top_level_entry_test = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
top_level_entry_test.main = function() {
|
||||
};
|
||||
dart.fn(top_level_entry_test.main, VoidTodynamic());
|
||||
// Exports:
|
||||
exports.top_level_entry_test = top_level_entry_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,24 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/top_level_multiple_files_test', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'expect'
|
||||
], function load__top_level_multiple_files_test(exports, dart_sdk, expect) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect$ = expect.expect;
|
||||
const top_level_multiple_files_test = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
top_level_multiple_files_test.main = function() {
|
||||
expect$.Expect.equals(top_level_multiple_files_test.topLevelVar, 42);
|
||||
expect$.Expect.equals(top_level_multiple_files_test.topLevelMethod(), 87);
|
||||
};
|
||||
dart.fn(top_level_multiple_files_test.main, VoidTodynamic());
|
||||
top_level_multiple_files_test.topLevelVar = 42;
|
||||
top_level_multiple_files_test.topLevelMethod = function() {
|
||||
return 87;
|
||||
};
|
||||
dart.fn(top_level_multiple_files_test.topLevelMethod, VoidTodynamic());
|
||||
// Exports:
|
||||
exports.top_level_multiple_files_test = top_level_multiple_files_test;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1 +1,26 @@
|
|||
//FAILED TO COMPILE
|
||||
dart_library.library('language/top_level_non_prefixed_library_test', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'expect'
|
||||
], function load__top_level_non_prefixed_library_test(exports, dart_sdk, expect) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const expect$ = expect.expect;
|
||||
const top_level_non_prefixed_library_test = Object.create(null);
|
||||
const top_level_prefixed_library_test = Object.create(null);
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
top_level_non_prefixed_library_test.main = function() {
|
||||
expect$.Expect.equals(top_level_prefixed_library_test.topLevelVar, 42);
|
||||
expect$.Expect.equals(top_level_prefixed_library_test.topLevelMethod(), 87);
|
||||
};
|
||||
dart.fn(top_level_non_prefixed_library_test.main, VoidTodynamic());
|
||||
top_level_prefixed_library_test.topLevelVar = 42;
|
||||
top_level_prefixed_library_test.topLevelMethod = function() {
|
||||
return 87;
|
||||
};
|
||||
dart.fn(top_level_prefixed_library_test.topLevelMethod, VoidTodynamic());
|
||||
// Exports:
|
||||
exports.top_level_non_prefixed_library_test = top_level_non_prefixed_library_test;
|
||||
exports.top_level_prefixed_library_test = top_level_prefixed_library_test;
|
||||
});
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
|
@ -1,797 +0,0 @@
|
|||
dart_library.library('stack_trace', null, /* Imports */[
|
||||
'dart_sdk',
|
||||
'path'
|
||||
], function load__stack_trace(exports, dart_sdk, path) {
|
||||
'use strict';
|
||||
const core = dart_sdk.core;
|
||||
const async = dart_sdk.async;
|
||||
const _interceptors = dart_sdk._interceptors;
|
||||
const math = dart_sdk.math;
|
||||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const path$ = path.path;
|
||||
const src__style = path.src__style;
|
||||
const src__chain = Object.create(null);
|
||||
const src__frame = Object.create(null);
|
||||
const src__lazy_trace = Object.create(null);
|
||||
const src__stack_zone_specification = Object.create(null);
|
||||
const src__trace = Object.create(null);
|
||||
const src__unparsed_frame = Object.create(null);
|
||||
const src__utils = Object.create(null);
|
||||
const src__vm_trace = Object.create(null);
|
||||
const stack_trace = Object.create(null);
|
||||
let JSArrayOfTrace = () => (JSArrayOfTrace = dart.constFn(_interceptors.JSArray$(src__trace.Trace)))();
|
||||
let ListOfTrace = () => (ListOfTrace = dart.constFn(core.List$(src__trace.Trace)))();
|
||||
let ListOfFrame = () => (ListOfFrame = dart.constFn(core.List$(src__frame.Frame)))();
|
||||
let dynamicAndChainTovoid = () => (dynamicAndChainTovoid = dart.constFn(dart.functionType(dart.void, [dart.dynamic, src__chain.Chain])))();
|
||||
let ListOfString = () => (ListOfString = dart.constFn(core.List$(core.String)))();
|
||||
let ExpandoOf_Node = () => (ExpandoOf_Node = dart.constFn(core.Expando$(src__stack_zone_specification._Node)))();
|
||||
let JSArrayOfFrame = () => (JSArrayOfFrame = dart.constFn(_interceptors.JSArray$(src__frame.Frame)))();
|
||||
let dynamicAnddynamicTodynamic = () => (dynamicAnddynamicTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [dart.dynamic, dart.dynamic])))();
|
||||
let VoidTodynamic = () => (VoidTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [])))();
|
||||
let StringToTrace = () => (StringToTrace = dart.constFn(dart.definiteFunctionType(src__trace.Trace, [core.String])))();
|
||||
let FrameTobool = () => (FrameTobool = dart.constFn(dart.definiteFunctionType(core.bool, [src__frame.Frame])))();
|
||||
let TraceToTrace = () => (TraceToTrace = dart.constFn(dart.definiteFunctionType(src__trace.Trace, [src__trace.Trace])))();
|
||||
let TraceTobool = () => (TraceTobool = dart.constFn(dart.definiteFunctionType(core.bool, [src__trace.Trace])))();
|
||||
let TraceToListOfFrame = () => (TraceToListOfFrame = dart.constFn(dart.definiteFunctionType(ListOfFrame(), [src__trace.Trace])))();
|
||||
let FrameToint = () => (FrameToint = dart.constFn(dart.definiteFunctionType(core.int, [src__frame.Frame])))();
|
||||
let TraceToint = () => (TraceToint = dart.constFn(dart.definiteFunctionType(core.int, [src__trace.Trace])))();
|
||||
let FrameToString = () => (FrameToString = dart.constFn(dart.definiteFunctionType(core.String, [src__frame.Frame])))();
|
||||
let TraceToString = () => (TraceToString = dart.constFn(dart.definiteFunctionType(core.String, [src__trace.Trace])))();
|
||||
let VoidToFrame = () => (VoidToFrame = dart.constFn(dart.definiteFunctionType(src__frame.Frame, [])))();
|
||||
let dynamicAnddynamicToFrame = () => (dynamicAnddynamicToFrame = dart.constFn(dart.definiteFunctionType(src__frame.Frame, [dart.dynamic, dart.dynamic])))();
|
||||
let VoidToTrace = () => (VoidToTrace = dart.constFn(dart.definiteFunctionType(src__trace.Trace, [])))();
|
||||
let ObjectAndStackTraceAndEventSinkTovoid = () => (ObjectAndStackTraceAndEventSinkTovoid = dart.constFn(dart.definiteFunctionType(dart.void, [core.Object, core.StackTrace, async.EventSink])))();
|
||||
let dynamicTodynamic = () => (dynamicTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [dart.dynamic])))();
|
||||
let StringToFrame = () => (StringToFrame = dart.constFn(dart.definiteFunctionType(src__frame.Frame, [core.String])))();
|
||||
let StringTobool = () => (StringTobool = dart.constFn(dart.definiteFunctionType(core.bool, [core.String])))();
|
||||
let FrameToFrame = () => (FrameToFrame = dart.constFn(dart.definiteFunctionType(src__frame.Frame, [src__frame.Frame])))();
|
||||
let StringAndintToString = () => (StringAndintToString = dart.constFn(dart.definiteFunctionType(core.String, [core.String, core.int])))();
|
||||
let MatchToString = () => (MatchToString = dart.constFn(dart.definiteFunctionType(core.String, [core.Match])))();
|
||||
src__chain.ChainHandler = dart.typedef('ChainHandler', () => dart.functionType(dart.void, [dart.dynamic, src__chain.Chain]));
|
||||
let const$;
|
||||
let const$0;
|
||||
src__chain.Chain = class Chain extends core.Object {
|
||||
static get _currentSpec() {
|
||||
return src__stack_zone_specification.StackZoneSpecification._check(async.Zone.current.get(const$ || (const$ = dart.const(core.Symbol.new('stack_trace.stack_zone.spec')))));
|
||||
}
|
||||
static capture(T) {
|
||||
return (callback, opts) => {
|
||||
let onError = opts && 'onError' in opts ? opts.onError : null;
|
||||
let when = opts && 'when' in opts ? opts.when : true;
|
||||
if (!dart.test(when)) {
|
||||
let newOnError = null;
|
||||
if (onError != null) {
|
||||
newOnError = dart.fn((error, stackTrace) => {
|
||||
dart.dcall(onError, error, src__chain.Chain.forTrace(core.StackTrace._check(stackTrace)));
|
||||
}, dynamicAnddynamicTodynamic());
|
||||
}
|
||||
return async.runZoned(T)(callback, {onError: core.Function._check(newOnError)});
|
||||
}
|
||||
let spec = new src__stack_zone_specification.StackZoneSpecification(onError);
|
||||
return T.as(async.runZoned(dart.dynamic)(dart.fn(() => {
|
||||
try {
|
||||
return callback();
|
||||
} catch (error) {
|
||||
let stackTrace = dart.stackTrace(error);
|
||||
return async.Zone.current.handleUncaughtError(dart.dynamic)(error, stackTrace);
|
||||
}
|
||||
|
||||
}, VoidTodynamic()), {zoneSpecification: spec.toSpec(), zoneValues: dart.map([const$0 || (const$0 = dart.const(core.Symbol.new('stack_trace.stack_zone.spec'))), spec], core.Symbol, src__stack_zone_specification.StackZoneSpecification)}));
|
||||
};
|
||||
}
|
||||
static track(futureOrStream) {
|
||||
return futureOrStream;
|
||||
}
|
||||
static current(level) {
|
||||
if (level === void 0) level = 0;
|
||||
if (src__chain.Chain._currentSpec != null) return src__chain.Chain._currentSpec.currentChain(dart.notNull(level) + 1);
|
||||
return new src__chain.Chain(JSArrayOfTrace().of([src__trace.Trace.current(dart.notNull(level) + 1)]));
|
||||
}
|
||||
static forTrace(trace) {
|
||||
if (src__chain.Chain.is(trace)) return trace;
|
||||
if (src__chain.Chain._currentSpec == null) return new src__chain.Chain(JSArrayOfTrace().of([src__trace.Trace.from(trace)]));
|
||||
return src__chain.Chain._currentSpec.chainFor(trace);
|
||||
}
|
||||
static parse(chain) {
|
||||
if (dart.test(chain[dartx.isEmpty])) return new src__chain.Chain(JSArrayOfTrace().of([]));
|
||||
if (!dart.test(chain[dartx.contains](src__utils.chainGap))) return new src__chain.Chain(JSArrayOfTrace().of([src__trace.Trace.parse(chain)]));
|
||||
return new src__chain.Chain(chain[dartx.split](src__utils.chainGap)[dartx.map](src__trace.Trace)(dart.fn(trace => new src__trace.Trace.parseFriendly(trace), StringToTrace())));
|
||||
}
|
||||
new(traces) {
|
||||
this.traces = ListOfTrace().unmodifiable(traces);
|
||||
}
|
||||
get terse() {
|
||||
return this.foldFrames(dart.fn(_ => false, FrameTobool()), {terse: true});
|
||||
}
|
||||
foldFrames(predicate, opts) {
|
||||
let terse = opts && 'terse' in opts ? opts.terse : false;
|
||||
let foldedTraces = this.traces[dartx.map](src__trace.Trace)(dart.fn(trace => trace.foldFrames(predicate, {terse: terse}), TraceToTrace()));
|
||||
let nonEmptyTraces = foldedTraces[dartx.where](dart.fn(trace => {
|
||||
if (dart.notNull(trace.frames[dartx.length]) > 1) return true;
|
||||
if (dart.test(trace.frames[dartx.isEmpty])) return false;
|
||||
if (!dart.test(terse)) return false;
|
||||
return trace.frames[dartx.single].line != null;
|
||||
}, TraceTobool()));
|
||||
if (dart.test(nonEmptyTraces[dartx.isEmpty]) && dart.test(foldedTraces[dartx.isNotEmpty])) {
|
||||
return new src__chain.Chain(JSArrayOfTrace().of([foldedTraces[dartx.last]]));
|
||||
}
|
||||
return new src__chain.Chain(nonEmptyTraces);
|
||||
}
|
||||
toTrace() {
|
||||
return new src__trace.Trace(this.traces[dartx.expand](src__frame.Frame)(dart.fn(trace => trace.frames, TraceToListOfFrame())));
|
||||
}
|
||||
toString() {
|
||||
let longest = this.traces[dartx.map](core.int)(dart.fn(trace => trace.frames[dartx.map](core.int)(dart.fn(frame => frame.location[dartx.length], FrameToint()))[dartx.fold](core.int)(0, dart.gbind(math.max, core.int)), TraceToint()))[dartx.fold](core.int)(0, dart.gbind(math.max, core.int));
|
||||
return this.traces[dartx.map](core.String)(dart.fn(trace => trace.frames[dartx.map](core.String)(dart.fn(frame => dart.str`${src__utils.padRight(frame.location, longest)} ${frame.member}\n`, FrameToString()))[dartx.join](), TraceToString()))[dartx.join](src__utils.chainGap);
|
||||
}
|
||||
};
|
||||
src__chain.Chain[dart.implements] = () => [core.StackTrace];
|
||||
dart.setSignature(src__chain.Chain, {
|
||||
constructors: () => ({
|
||||
current: dart.definiteFunctionType(src__chain.Chain, [], [core.int]),
|
||||
forTrace: dart.definiteFunctionType(src__chain.Chain, [core.StackTrace]),
|
||||
parse: dart.definiteFunctionType(src__chain.Chain, [core.String]),
|
||||
new: dart.definiteFunctionType(src__chain.Chain, [core.Iterable$(src__trace.Trace)])
|
||||
}),
|
||||
methods: () => ({
|
||||
foldFrames: dart.definiteFunctionType(src__chain.Chain, [dart.functionType(core.bool, [src__frame.Frame])], {terse: core.bool}),
|
||||
toTrace: dart.definiteFunctionType(src__trace.Trace, [])
|
||||
}),
|
||||
statics: () => ({
|
||||
capture: dart.definiteFunctionType(T => [T, [dart.functionType(T, [])], {onError: dynamicAndChainTovoid(), when: core.bool}]),
|
||||
track: dart.definiteFunctionType(dart.dynamic, [dart.dynamic])
|
||||
}),
|
||||
names: ['capture', 'track']
|
||||
});
|
||||
dart.defineLazy(src__frame, {
|
||||
get _vmFrame() {
|
||||
return core.RegExp.new('^#\\d+\\s+(\\S.*) \\((.+?)((?::\\d+){0,2})\\)$');
|
||||
}
|
||||
});
|
||||
dart.defineLazy(src__frame, {
|
||||
get _v8Frame() {
|
||||
return core.RegExp.new('^\\s*at (?:(\\S.*?)(?: \\[as [^\\]]+\\])? \\((.*)\\)|(.*))$');
|
||||
}
|
||||
});
|
||||
dart.defineLazy(src__frame, {
|
||||
get _v8UrlLocation() {
|
||||
return core.RegExp.new('^(.*):(\\d+):(\\d+)|native$');
|
||||
}
|
||||
});
|
||||
dart.defineLazy(src__frame, {
|
||||
get _v8EvalLocation() {
|
||||
return core.RegExp.new('^eval at (?:\\S.*?) \\((.*)\\)(?:, .*?:\\d+:\\d+)?$');
|
||||
}
|
||||
});
|
||||
dart.defineLazy(src__frame, {
|
||||
get _firefoxSafariFrame() {
|
||||
return core.RegExp.new('^' + '(?:' + '([^@(/]*)' + '(?:\\(.*\\))?' + '((?:/[^/]*)*)' + '(?:\\(.*\\))?' + '@' + ')?' + '(.*?)' + ':' + '(\\d*)' + '(?::(\\d*))?' + '$');
|
||||
}
|
||||
});
|
||||
dart.defineLazy(src__frame, {
|
||||
get _friendlyFrame() {
|
||||
return core.RegExp.new('^(\\S+)(?: (\\d+)(?::(\\d+))?)?\\s+([^\\d]\\S*)$');
|
||||
}
|
||||
});
|
||||
dart.defineLazy(src__frame, {
|
||||
get _asyncBody() {
|
||||
return core.RegExp.new('<(<anonymous closure>|[^>]+)_async_body>');
|
||||
}
|
||||
});
|
||||
dart.defineLazy(src__frame, {
|
||||
get _initialDot() {
|
||||
return core.RegExp.new("^\\.");
|
||||
}
|
||||
});
|
||||
src__frame.Frame = class Frame extends core.Object {
|
||||
get isCore() {
|
||||
return this.uri.scheme == 'dart';
|
||||
}
|
||||
get library() {
|
||||
if (this.uri.scheme == 'data') return "data:...";
|
||||
return path$.prettyUri(this.uri);
|
||||
}
|
||||
get package() {
|
||||
if (this.uri.scheme != 'package') return null;
|
||||
return this.uri.path[dartx.split]('/')[dartx.first];
|
||||
}
|
||||
get location() {
|
||||
if (this.line == null) return this.library;
|
||||
if (this.column == null) return dart.str`${this.library} ${this.line}`;
|
||||
return dart.str`${this.library} ${this.line}:${this.column}`;
|
||||
}
|
||||
static caller(level) {
|
||||
if (level === void 0) level = 1;
|
||||
if (dart.notNull(level) < 0) {
|
||||
dart.throw(new core.ArgumentError("Argument [level] must be greater than or equal " + "to 0."));
|
||||
}
|
||||
return src__trace.Trace.current(dart.notNull(level) + 1).frames[dartx.first];
|
||||
}
|
||||
static parseVM(frame) {
|
||||
return src__frame.Frame._catchFormatException(frame, dart.fn(() => {
|
||||
if (frame == '...') {
|
||||
return new src__frame.Frame(core.Uri.new(), null, null, '...');
|
||||
}
|
||||
let match = src__frame._vmFrame.firstMatch(frame);
|
||||
if (match == null) return new src__unparsed_frame.UnparsedFrame(frame);
|
||||
let member = match.get(1)[dartx.replaceAll](src__frame._asyncBody, "<async>")[dartx.replaceAll]("<anonymous closure>", "<fn>");
|
||||
let uri = core.Uri.parse(match.get(2));
|
||||
let lineAndColumn = match.get(3)[dartx.split](':');
|
||||
let line = dart.notNull(lineAndColumn[dartx.length]) > 1 ? core.int.parse(lineAndColumn[dartx.get](1)) : null;
|
||||
let column = dart.notNull(lineAndColumn[dartx.length]) > 2 ? core.int.parse(lineAndColumn[dartx.get](2)) : null;
|
||||
return new src__frame.Frame(uri, line, column, member);
|
||||
}, VoidToFrame()));
|
||||
}
|
||||
static parseV8(frame) {
|
||||
return src__frame.Frame._catchFormatException(frame, dart.fn(() => {
|
||||
let match = src__frame._v8Frame.firstMatch(frame);
|
||||
if (match == null) return new src__unparsed_frame.UnparsedFrame(frame);
|
||||
function parseLocation(location, member) {
|
||||
let evalMatch = src__frame._v8EvalLocation.firstMatch(core.String._check(location));
|
||||
while (evalMatch != null) {
|
||||
location = evalMatch.get(1);
|
||||
evalMatch = src__frame._v8EvalLocation.firstMatch(core.String._check(location));
|
||||
}
|
||||
if (dart.equals(location, 'native')) {
|
||||
return new src__frame.Frame(core.Uri.parse('native'), null, null, core.String._check(member));
|
||||
}
|
||||
let urlMatch = src__frame._v8UrlLocation.firstMatch(core.String._check(location));
|
||||
if (urlMatch == null) return new src__unparsed_frame.UnparsedFrame(frame);
|
||||
return new src__frame.Frame(src__frame.Frame._uriOrPathToUri(urlMatch.get(1)), core.int.parse(urlMatch.get(2)), core.int.parse(urlMatch.get(3)), core.String._check(member));
|
||||
}
|
||||
dart.fn(parseLocation, dynamicAnddynamicToFrame());
|
||||
if (match.get(2) != null) {
|
||||
return parseLocation(match.get(2), match.get(1)[dartx.replaceAll]("<anonymous>", "<fn>")[dartx.replaceAll]("Anonymous function", "<fn>"));
|
||||
} else {
|
||||
return parseLocation(match.get(3), "<fn>");
|
||||
}
|
||||
}, VoidToFrame()));
|
||||
}
|
||||
static parseJSCore(frame) {
|
||||
return src__frame.Frame.parseV8(frame);
|
||||
}
|
||||
static parseIE(frame) {
|
||||
return src__frame.Frame.parseV8(frame);
|
||||
}
|
||||
static parseFirefox(frame) {
|
||||
return src__frame.Frame._catchFormatException(frame, dart.fn(() => {
|
||||
let match = src__frame._firefoxSafariFrame.firstMatch(frame);
|
||||
if (match == null) return new src__unparsed_frame.UnparsedFrame(frame);
|
||||
let uri = src__frame.Frame._uriOrPathToUri(match.get(3));
|
||||
let member = null;
|
||||
if (match.get(1) != null) {
|
||||
member = match.get(1);
|
||||
member = dart.dsend(member, '+', ListOfString().filled('/'[dartx.allMatches](match.get(2))[dartx.length], ".<fn>")[dartx.join]());
|
||||
if (dart.equals(member, '')) member = '<fn>';
|
||||
member = dart.dsend(member, 'replaceFirst', src__frame._initialDot, '');
|
||||
} else {
|
||||
member = '<fn>';
|
||||
}
|
||||
let line = match.get(4) == '' ? null : core.int.parse(match.get(4));
|
||||
let column = match.get(5) == null || match.get(5) == '' ? null : core.int.parse(match.get(5));
|
||||
return new src__frame.Frame(uri, line, column, core.String._check(member));
|
||||
}, VoidToFrame()));
|
||||
}
|
||||
static parseSafari6_0(frame) {
|
||||
return src__frame.Frame.parseFirefox(frame);
|
||||
}
|
||||
static parseSafari6_1(frame) {
|
||||
return src__frame.Frame.parseFirefox(frame);
|
||||
}
|
||||
static parseSafari(frame) {
|
||||
return src__frame.Frame.parseFirefox(frame);
|
||||
}
|
||||
static parseFriendly(frame) {
|
||||
return src__frame.Frame._catchFormatException(frame, dart.fn(() => {
|
||||
let match = src__frame._friendlyFrame.firstMatch(frame);
|
||||
if (match == null) {
|
||||
dart.throw(new core.FormatException(dart.str`Couldn't parse package:stack_trace stack trace line '${frame}'.`));
|
||||
}
|
||||
let uri = core.Uri.parse(match.get(1));
|
||||
if (uri.scheme == '') {
|
||||
uri = path$.toUri(path$.absolute(path$.fromUri(uri)));
|
||||
}
|
||||
let line = match.get(2) == null ? null : core.int.parse(match.get(2));
|
||||
let column = match.get(3) == null ? null : core.int.parse(match.get(3));
|
||||
return new src__frame.Frame(uri, line, column, match.get(4));
|
||||
}, VoidToFrame()));
|
||||
}
|
||||
static _uriOrPathToUri(uriOrPath) {
|
||||
if (dart.test(uriOrPath[dartx.contains](src__frame.Frame._uriRegExp))) {
|
||||
return core.Uri.parse(uriOrPath);
|
||||
} else if (dart.test(uriOrPath[dartx.contains](src__frame.Frame._windowsRegExp))) {
|
||||
return core.Uri.file(uriOrPath, {windows: true});
|
||||
} else if (dart.test(uriOrPath[dartx.startsWith]('/'))) {
|
||||
return core.Uri.file(uriOrPath, {windows: false});
|
||||
}
|
||||
if (dart.test(uriOrPath[dartx.contains]('\\'))) return path$.windows.toUri(uriOrPath);
|
||||
return core.Uri.parse(uriOrPath);
|
||||
}
|
||||
static _catchFormatException(text, body) {
|
||||
try {
|
||||
return body();
|
||||
} catch (_) {
|
||||
if (core.FormatException.is(_)) {
|
||||
return new src__unparsed_frame.UnparsedFrame(text);
|
||||
} else
|
||||
throw _;
|
||||
}
|
||||
|
||||
}
|
||||
new(uri, line, column, member) {
|
||||
this.uri = uri;
|
||||
this.line = line;
|
||||
this.column = column;
|
||||
this.member = member;
|
||||
}
|
||||
toString() {
|
||||
return dart.str`${this.location} in ${this.member}`;
|
||||
}
|
||||
};
|
||||
dart.setSignature(src__frame.Frame, {
|
||||
constructors: () => ({
|
||||
caller: dart.definiteFunctionType(src__frame.Frame, [], [core.int]),
|
||||
parseVM: dart.definiteFunctionType(src__frame.Frame, [core.String]),
|
||||
parseV8: dart.definiteFunctionType(src__frame.Frame, [core.String]),
|
||||
parseJSCore: dart.definiteFunctionType(src__frame.Frame, [core.String]),
|
||||
parseIE: dart.definiteFunctionType(src__frame.Frame, [core.String]),
|
||||
parseFirefox: dart.definiteFunctionType(src__frame.Frame, [core.String]),
|
||||
parseSafari6_0: dart.definiteFunctionType(src__frame.Frame, [core.String]),
|
||||
parseSafari6_1: dart.definiteFunctionType(src__frame.Frame, [core.String]),
|
||||
parseSafari: dart.definiteFunctionType(src__frame.Frame, [core.String]),
|
||||
parseFriendly: dart.definiteFunctionType(src__frame.Frame, [core.String]),
|
||||
new: dart.definiteFunctionType(src__frame.Frame, [core.Uri, core.int, core.int, core.String])
|
||||
}),
|
||||
statics: () => ({
|
||||
_uriOrPathToUri: dart.definiteFunctionType(core.Uri, [core.String]),
|
||||
_catchFormatException: dart.definiteFunctionType(src__frame.Frame, [core.String, dart.functionType(src__frame.Frame, [])])
|
||||
}),
|
||||
names: ['_uriOrPathToUri', '_catchFormatException']
|
||||
});
|
||||
dart.defineLazy(src__frame.Frame, {
|
||||
get _uriRegExp() {
|
||||
return core.RegExp.new('^[a-zA-Z][-+.a-zA-Z\\d]*://');
|
||||
},
|
||||
get _windowsRegExp() {
|
||||
return core.RegExp.new('^([a-zA-Z]:[\\\\/]|\\\\\\\\)');
|
||||
}
|
||||
});
|
||||
src__lazy_trace.TraceThunk = dart.typedef('TraceThunk', () => dart.functionType(src__trace.Trace, []));
|
||||
const _thunk = Symbol('_thunk');
|
||||
const _inner = Symbol('_inner');
|
||||
const _trace = Symbol('_trace');
|
||||
src__lazy_trace.LazyTrace = class LazyTrace extends core.Object {
|
||||
new(thunk) {
|
||||
this[_thunk] = thunk;
|
||||
this[_inner] = null;
|
||||
}
|
||||
get [_trace]() {
|
||||
if (this[_inner] == null) this[_inner] = this[_thunk]();
|
||||
return this[_inner];
|
||||
}
|
||||
get frames() {
|
||||
return this[_trace].frames;
|
||||
}
|
||||
get vmTrace() {
|
||||
return this[_trace].vmTrace;
|
||||
}
|
||||
get terse() {
|
||||
return new src__lazy_trace.LazyTrace(dart.fn(() => this[_trace].terse, VoidToTrace()));
|
||||
}
|
||||
foldFrames(predicate, opts) {
|
||||
let terse = opts && 'terse' in opts ? opts.terse : false;
|
||||
return new src__lazy_trace.LazyTrace(dart.fn(() => this[_trace].foldFrames(predicate, {terse: terse}), VoidToTrace()));
|
||||
}
|
||||
toString() {
|
||||
return dart.toString(this[_trace]);
|
||||
}
|
||||
set frames(_) {
|
||||
return dart.throw(new core.UnimplementedError());
|
||||
}
|
||||
};
|
||||
src__lazy_trace.LazyTrace[dart.implements] = () => [src__trace.Trace];
|
||||
dart.setSignature(src__lazy_trace.LazyTrace, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(src__lazy_trace.LazyTrace, [src__lazy_trace.TraceThunk])}),
|
||||
methods: () => ({foldFrames: dart.definiteFunctionType(src__trace.Trace, [dart.functionType(core.bool, [src__frame.Frame])], {terse: core.bool})})
|
||||
});
|
||||
src__stack_zone_specification._ChainHandler = dart.typedef('_ChainHandler', () => dart.functionType(dart.void, [dart.dynamic, src__chain.Chain]));
|
||||
const _chains = Symbol('_chains');
|
||||
const _onError = Symbol('_onError');
|
||||
const _currentNode = Symbol('_currentNode');
|
||||
const _createNode = Symbol('_createNode');
|
||||
const _run = Symbol('_run');
|
||||
src__stack_zone_specification.StackZoneSpecification = class StackZoneSpecification extends core.Object {
|
||||
new(onError) {
|
||||
if (onError === void 0) onError = null;
|
||||
this[_chains] = new (ExpandoOf_Node())("stack chains");
|
||||
this[_onError] = onError;
|
||||
this[_currentNode] = null;
|
||||
}
|
||||
toSpec() {
|
||||
return async.ZoneSpecification.new({handleUncaughtError: dart.bind(this, 'handleUncaughtError'), registerCallback: dart.bind(this, 'registerCallback'), registerUnaryCallback: dart.bind(this, 'registerUnaryCallback'), registerBinaryCallback: dart.bind(this, 'registerBinaryCallback'), errorCallback: dart.bind(this, 'errorCallback')});
|
||||
}
|
||||
currentChain(level) {
|
||||
if (level === void 0) level = 0;
|
||||
return this[_createNode](dart.notNull(level) + 1).toChain();
|
||||
}
|
||||
chainFor(trace) {
|
||||
if (src__chain.Chain.is(trace)) return trace;
|
||||
let previous = trace == null ? null : this[_chains].get(trace);
|
||||
return new src__stack_zone_specification._Node(trace, previous).toChain();
|
||||
}
|
||||
trackFuture(future, level) {
|
||||
if (level === void 0) level = 0;
|
||||
let completer = async.Completer.sync();
|
||||
let node = this[_createNode](dart.notNull(level) + 1);
|
||||
future.then(dart.dynamic)(dart.bind(completer, 'complete')).catchError(dart.fn((e, stackTrace) => {
|
||||
if (stackTrace == null) stackTrace = src__trace.Trace.current();
|
||||
if (!src__chain.Chain.is(stackTrace) && this[_chains].get(stackTrace) == null) {
|
||||
this[_chains].set(stackTrace, node);
|
||||
}
|
||||
completer.completeError(e, core.StackTrace._check(stackTrace));
|
||||
}, dynamicAnddynamicTodynamic()));
|
||||
return completer.future;
|
||||
}
|
||||
trackStream(stream, level) {
|
||||
if (level === void 0) level = 0;
|
||||
let node = this[_createNode](dart.notNull(level) + 1);
|
||||
return stream.transform(dart.dynamic)(async.StreamTransformer.fromHandlers({handleError: dart.fn((error, stackTrace, sink) => {
|
||||
if (stackTrace == null) stackTrace = src__trace.Trace.current();
|
||||
if (!src__chain.Chain.is(stackTrace) && this[_chains].get(stackTrace) == null) {
|
||||
this[_chains].set(stackTrace, node);
|
||||
}
|
||||
sink.addError(error, stackTrace);
|
||||
}, ObjectAndStackTraceAndEventSinkTovoid())}));
|
||||
}
|
||||
registerCallback(self, parent, zone, f) {
|
||||
if (f == null) return parent.registerCallback(dart.dynamic)(zone, null);
|
||||
let node = this[_createNode](1);
|
||||
return parent.registerCallback(dart.dynamic)(zone, dart.fn(() => this[_run](f, node), VoidTodynamic()));
|
||||
}
|
||||
registerUnaryCallback(self, parent, zone, f) {
|
||||
if (f == null) return parent.registerUnaryCallback(dart.dynamic, dart.dynamic)(zone, null);
|
||||
let node = this[_createNode](1);
|
||||
return parent.registerUnaryCallback(dart.dynamic, dart.dynamic)(zone, dart.fn(arg => this[_run](dart.fn(() => dart.dcall(f, arg), VoidTodynamic()), node), dynamicTodynamic()));
|
||||
}
|
||||
registerBinaryCallback(self, parent, zone, f) {
|
||||
if (f == null) return parent.registerBinaryCallback(dart.dynamic, dart.dynamic, dart.dynamic)(zone, null);
|
||||
let node = this[_createNode](1);
|
||||
return parent.registerBinaryCallback(dart.dynamic, dart.dynamic, dart.dynamic)(zone, dart.fn((arg1, arg2) => this[_run](dart.fn(() => dart.dcall(f, arg1, arg2), VoidTodynamic()), node), dynamicAnddynamicTodynamic()));
|
||||
}
|
||||
handleUncaughtError(self, parent, zone, error, stackTrace) {
|
||||
let stackChain = this.chainFor(stackTrace);
|
||||
if (this[_onError] == null) {
|
||||
return parent.handleUncaughtError(dart.dynamic)(zone, error, stackChain);
|
||||
}
|
||||
try {
|
||||
return parent.runBinary(dart.dynamic, dart.dynamic, src__chain.Chain)(zone, this[_onError], error, stackChain);
|
||||
} catch (newError) {
|
||||
let newStackTrace = dart.stackTrace(newError);
|
||||
if (core.identical(newError, error)) {
|
||||
return parent.handleUncaughtError(dart.dynamic)(zone, error, stackChain);
|
||||
} else {
|
||||
return parent.handleUncaughtError(dart.dynamic)(zone, newError, newStackTrace);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
errorCallback(self, parent, zone, error, stackTrace) {
|
||||
if (stackTrace == null) {
|
||||
stackTrace = this[_createNode](2).toChain();
|
||||
} else {
|
||||
if (this[_chains].get(stackTrace) == null) this[_chains].set(stackTrace, this[_createNode](2));
|
||||
}
|
||||
let asyncError = parent.errorCallback(zone, error, stackTrace);
|
||||
return asyncError == null ? new async.AsyncError(error, stackTrace) : asyncError;
|
||||
}
|
||||
[_createNode](level) {
|
||||
if (level === void 0) level = 0;
|
||||
return new src__stack_zone_specification._Node(src__trace.Trace.current(dart.notNull(level) + 1), this[_currentNode]);
|
||||
}
|
||||
[_run](f, node) {
|
||||
let previousNode = this[_currentNode];
|
||||
this[_currentNode] = node;
|
||||
try {
|
||||
return dart.dcall(f);
|
||||
} catch (e) {
|
||||
let stackTrace = dart.stackTrace(e);
|
||||
this[_chains].set(stackTrace, node);
|
||||
throw e;
|
||||
}
|
||||
finally {
|
||||
this[_currentNode] = previousNode;
|
||||
}
|
||||
}
|
||||
};
|
||||
dart.setSignature(src__stack_zone_specification.StackZoneSpecification, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(src__stack_zone_specification.StackZoneSpecification, [], [src__stack_zone_specification._ChainHandler])}),
|
||||
methods: () => ({
|
||||
toSpec: dart.definiteFunctionType(async.ZoneSpecification, []),
|
||||
currentChain: dart.definiteFunctionType(src__chain.Chain, [], [core.int]),
|
||||
chainFor: dart.definiteFunctionType(src__chain.Chain, [core.StackTrace]),
|
||||
trackFuture: dart.definiteFunctionType(async.Future, [async.Future], [core.int]),
|
||||
trackStream: dart.definiteFunctionType(async.Stream, [async.Stream], [core.int]),
|
||||
registerCallback: dart.definiteFunctionType(async.ZoneCallback, [async.Zone, async.ZoneDelegate, async.Zone, core.Function]),
|
||||
registerUnaryCallback: dart.definiteFunctionType(async.ZoneUnaryCallback, [async.Zone, async.ZoneDelegate, async.Zone, core.Function]),
|
||||
registerBinaryCallback: dart.definiteFunctionType(async.ZoneBinaryCallback, [async.Zone, async.ZoneDelegate, async.Zone, core.Function]),
|
||||
handleUncaughtError: dart.definiteFunctionType(dart.dynamic, [async.Zone, async.ZoneDelegate, async.Zone, dart.dynamic, core.StackTrace]),
|
||||
errorCallback: dart.definiteFunctionType(async.AsyncError, [async.Zone, async.ZoneDelegate, async.Zone, core.Object, core.StackTrace]),
|
||||
[_createNode]: dart.definiteFunctionType(src__stack_zone_specification._Node, [], [core.int]),
|
||||
[_run]: dart.definiteFunctionType(dart.dynamic, [core.Function, src__stack_zone_specification._Node])
|
||||
})
|
||||
});
|
||||
src__stack_zone_specification._Node = class _Node extends core.Object {
|
||||
new(trace, previous) {
|
||||
if (previous === void 0) previous = null;
|
||||
this.previous = previous;
|
||||
this.trace = trace == null ? src__trace.Trace.current() : src__trace.Trace.from(trace);
|
||||
}
|
||||
toChain() {
|
||||
let nodes = JSArrayOfTrace().of([]);
|
||||
let node = this;
|
||||
while (node != null) {
|
||||
nodes[dartx.add](node.trace);
|
||||
node = node.previous;
|
||||
}
|
||||
return new src__chain.Chain(nodes);
|
||||
}
|
||||
};
|
||||
dart.setSignature(src__stack_zone_specification._Node, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(src__stack_zone_specification._Node, [core.StackTrace], [src__stack_zone_specification._Node])}),
|
||||
methods: () => ({toChain: dart.definiteFunctionType(src__chain.Chain, [])})
|
||||
});
|
||||
dart.defineLazy(src__trace, {
|
||||
get _terseRegExp() {
|
||||
return core.RegExp.new("(-patch)?([/\\\\].*)?$");
|
||||
}
|
||||
});
|
||||
dart.defineLazy(src__trace, {
|
||||
get _v8Trace() {
|
||||
return core.RegExp.new("\\n ?at ");
|
||||
}
|
||||
});
|
||||
dart.defineLazy(src__trace, {
|
||||
get _v8TraceLine() {
|
||||
return core.RegExp.new(" ?at ");
|
||||
}
|
||||
});
|
||||
dart.defineLazy(src__trace, {
|
||||
get _firefoxSafariTrace() {
|
||||
return core.RegExp.new("^" + "(" + "([.0-9A-Za-z_$/<]|\\(.*\\))*" + "@" + ")?" + "[^\\s]*" + ":\\d*" + "$", {multiLine: true});
|
||||
}
|
||||
});
|
||||
dart.defineLazy(src__trace, {
|
||||
get _friendlyTrace() {
|
||||
return core.RegExp.new("^[^\\s]+( \\d+(:\\d+)?)?[ \\t]+[^\\s]+$", {multiLine: true});
|
||||
}
|
||||
});
|
||||
src__trace.Trace = class Trace extends core.Object {
|
||||
static format(stackTrace, opts) {
|
||||
let terse = opts && 'terse' in opts ? opts.terse : true;
|
||||
let trace = src__trace.Trace.from(stackTrace);
|
||||
if (dart.test(terse)) trace = trace.terse;
|
||||
return dart.toString(trace);
|
||||
}
|
||||
static current(level) {
|
||||
if (level === void 0) level = 0;
|
||||
if (dart.notNull(level) < 0) {
|
||||
dart.throw(new core.ArgumentError("Argument [level] must be greater than or equal " + "to 0."));
|
||||
}
|
||||
let trace = src__trace.Trace.from(core.StackTrace.current);
|
||||
return new src__lazy_trace.LazyTrace(dart.fn(() => new src__trace.Trace(trace.frames[dartx.skip](dart.notNull(level) + (dart.test(src__utils.inJS) ? 2 : 1))), VoidToTrace()));
|
||||
}
|
||||
static from(trace) {
|
||||
if (trace == null) {
|
||||
dart.throw(new core.ArgumentError("Cannot create a Trace from null."));
|
||||
}
|
||||
if (src__trace.Trace.is(trace)) return trace;
|
||||
if (src__chain.Chain.is(trace)) return trace.toTrace();
|
||||
return new src__lazy_trace.LazyTrace(dart.fn(() => src__trace.Trace.parse(dart.toString(trace)), VoidToTrace()));
|
||||
}
|
||||
static parse(trace) {
|
||||
try {
|
||||
if (dart.test(trace[dartx.isEmpty])) return new src__trace.Trace(JSArrayOfFrame().of([]));
|
||||
if (dart.test(trace[dartx.contains](src__trace._v8Trace))) return new src__trace.Trace.parseV8(trace);
|
||||
if (dart.test(trace[dartx.contains]("\tat "))) return new src__trace.Trace.parseJSCore(trace);
|
||||
if (dart.test(trace[dartx.contains](src__trace._firefoxSafariTrace))) {
|
||||
return new src__trace.Trace.parseFirefox(trace);
|
||||
}
|
||||
if (dart.test(trace[dartx.contains](src__utils.chainGap))) return src__chain.Chain.parse(trace).toTrace();
|
||||
if (dart.test(trace[dartx.contains](src__trace._friendlyTrace))) {
|
||||
return new src__trace.Trace.parseFriendly(trace);
|
||||
}
|
||||
return new src__trace.Trace.parseVM(trace);
|
||||
} catch (error) {
|
||||
if (core.FormatException.is(error)) {
|
||||
dart.throw(new core.FormatException(dart.str`${error.message}\nStack trace:\n${trace}`));
|
||||
} else
|
||||
throw error;
|
||||
}
|
||||
|
||||
}
|
||||
parseVM(trace) {
|
||||
Trace.prototype.new.call(this, src__trace.Trace._parseVM(trace));
|
||||
}
|
||||
static _parseVM(trace) {
|
||||
let lines = trace[dartx.trim]()[dartx.split]("\n");
|
||||
let frames = lines[dartx.take](dart.notNull(lines[dartx.length]) - 1)[dartx.map](src__frame.Frame)(dart.fn(line => src__frame.Frame.parseVM(line), StringToFrame()))[dartx.toList]();
|
||||
if (!dart.test(lines[dartx.last][dartx.endsWith](".da"))) {
|
||||
frames[dartx.add](src__frame.Frame.parseVM(lines[dartx.last]));
|
||||
}
|
||||
return frames;
|
||||
}
|
||||
parseV8(trace) {
|
||||
Trace.prototype.new.call(this, trace[dartx.split]("\n")[dartx.skip](1)[dartx.skipWhile](dart.fn(line => !dart.test(line[dartx.startsWith](src__trace._v8TraceLine)), StringTobool()))[dartx.map](src__frame.Frame)(dart.fn(line => src__frame.Frame.parseV8(line), StringToFrame())));
|
||||
}
|
||||
parseJSCore(trace) {
|
||||
Trace.prototype.new.call(this, trace[dartx.split]("\n")[dartx.where](dart.fn(line => line != "\tat ", StringTobool()))[dartx.map](src__frame.Frame)(dart.fn(line => src__frame.Frame.parseV8(line), StringToFrame())));
|
||||
}
|
||||
parseIE(trace) {
|
||||
Trace.prototype.parseV8.call(this, trace);
|
||||
}
|
||||
parseFirefox(trace) {
|
||||
Trace.prototype.new.call(this, trace[dartx.trim]()[dartx.split]("\n")[dartx.where](dart.fn(line => dart.test(line[dartx.isNotEmpty]) && line != '[native code]', StringTobool()))[dartx.map](src__frame.Frame)(dart.fn(line => src__frame.Frame.parseFirefox(line), StringToFrame())));
|
||||
}
|
||||
parseSafari(trace) {
|
||||
Trace.prototype.parseFirefox.call(this, trace);
|
||||
}
|
||||
parseSafari6_1(trace) {
|
||||
Trace.prototype.parseSafari.call(this, trace);
|
||||
}
|
||||
parseSafari6_0(trace) {
|
||||
Trace.prototype.new.call(this, trace[dartx.trim]()[dartx.split]("\n")[dartx.where](dart.fn(line => line != '[native code]', StringTobool()))[dartx.map](src__frame.Frame)(dart.fn(line => src__frame.Frame.parseFirefox(line), StringToFrame())));
|
||||
}
|
||||
parseFriendly(trace) {
|
||||
Trace.prototype.new.call(this, dart.test(trace[dartx.isEmpty]) ? JSArrayOfFrame().of([]) : trace[dartx.trim]()[dartx.split]("\n")[dartx.where](dart.fn(line => !dart.test(line[dartx.startsWith]('=====')), StringTobool()))[dartx.map](src__frame.Frame)(dart.fn(line => src__frame.Frame.parseFriendly(line), StringToFrame())));
|
||||
}
|
||||
new(frames) {
|
||||
this.frames = ListOfFrame().unmodifiable(frames);
|
||||
}
|
||||
get vmTrace() {
|
||||
return new src__vm_trace.VMTrace(this.frames);
|
||||
}
|
||||
get terse() {
|
||||
return this.foldFrames(dart.fn(_ => false, FrameTobool()), {terse: true});
|
||||
}
|
||||
foldFrames(predicate, opts) {
|
||||
let terse = opts && 'terse' in opts ? opts.terse : false;
|
||||
if (dart.test(terse)) {
|
||||
let oldPredicate = predicate;
|
||||
predicate = dart.fn(frame => {
|
||||
if (dart.test(oldPredicate(frame))) return true;
|
||||
if (dart.test(frame.isCore)) return true;
|
||||
if (frame.package == 'stack_trace') return true;
|
||||
if (!dart.test(frame.member[dartx.contains]('<async>'))) return false;
|
||||
return frame.line == null;
|
||||
}, FrameTobool());
|
||||
}
|
||||
let newFrames = JSArrayOfFrame().of([]);
|
||||
for (let frame of this.frames[dartx.reversed]) {
|
||||
if (src__unparsed_frame.UnparsedFrame.is(frame) || !dart.test(predicate(frame))) {
|
||||
newFrames[dartx.add](frame);
|
||||
} else if (dart.test(newFrames[dartx.isEmpty]) || !dart.test(predicate(newFrames[dartx.last]))) {
|
||||
newFrames[dartx.add](new src__frame.Frame(frame.uri, frame.line, frame.column, frame.member));
|
||||
}
|
||||
}
|
||||
if (dart.test(terse)) {
|
||||
newFrames = newFrames[dartx.map](src__frame.Frame)(dart.fn(frame => {
|
||||
if (src__unparsed_frame.UnparsedFrame.is(frame) || !dart.test(predicate(frame))) return frame;
|
||||
let library = frame.library[dartx.replaceAll](src__trace._terseRegExp, '');
|
||||
return new src__frame.Frame(core.Uri.parse(library), null, null, frame.member);
|
||||
}, FrameToFrame()))[dartx.toList]();
|
||||
if (dart.notNull(newFrames[dartx.length]) > 1 && dart.test(newFrames[dartx.first].isCore)) newFrames[dartx.removeAt](0);
|
||||
}
|
||||
return new src__trace.Trace(newFrames[dartx.reversed]);
|
||||
}
|
||||
toString() {
|
||||
let longest = this.frames[dartx.map](core.int)(dart.fn(frame => frame.location[dartx.length], FrameToint()))[dartx.fold](core.int)(0, dart.gbind(math.max, core.int));
|
||||
return this.frames[dartx.map](core.String)(dart.fn(frame => {
|
||||
if (src__unparsed_frame.UnparsedFrame.is(frame)) return dart.str`${frame}\n`;
|
||||
return dart.str`${src__utils.padRight(frame.location, longest)} ${frame.member}\n`;
|
||||
}, FrameToString()))[dartx.join]();
|
||||
}
|
||||
};
|
||||
dart.defineNamedConstructor(src__trace.Trace, 'parseVM');
|
||||
dart.defineNamedConstructor(src__trace.Trace, 'parseV8');
|
||||
dart.defineNamedConstructor(src__trace.Trace, 'parseJSCore');
|
||||
dart.defineNamedConstructor(src__trace.Trace, 'parseIE');
|
||||
dart.defineNamedConstructor(src__trace.Trace, 'parseFirefox');
|
||||
dart.defineNamedConstructor(src__trace.Trace, 'parseSafari');
|
||||
dart.defineNamedConstructor(src__trace.Trace, 'parseSafari6_1');
|
||||
dart.defineNamedConstructor(src__trace.Trace, 'parseSafari6_0');
|
||||
dart.defineNamedConstructor(src__trace.Trace, 'parseFriendly');
|
||||
src__trace.Trace[dart.implements] = () => [core.StackTrace];
|
||||
dart.setSignature(src__trace.Trace, {
|
||||
constructors: () => ({
|
||||
current: dart.definiteFunctionType(src__trace.Trace, [], [core.int]),
|
||||
from: dart.definiteFunctionType(src__trace.Trace, [core.StackTrace]),
|
||||
parse: dart.definiteFunctionType(src__trace.Trace, [core.String]),
|
||||
parseVM: dart.definiteFunctionType(src__trace.Trace, [core.String]),
|
||||
parseV8: dart.definiteFunctionType(src__trace.Trace, [core.String]),
|
||||
parseJSCore: dart.definiteFunctionType(src__trace.Trace, [core.String]),
|
||||
parseIE: dart.definiteFunctionType(src__trace.Trace, [core.String]),
|
||||
parseFirefox: dart.definiteFunctionType(src__trace.Trace, [core.String]),
|
||||
parseSafari: dart.definiteFunctionType(src__trace.Trace, [core.String]),
|
||||
parseSafari6_1: dart.definiteFunctionType(src__trace.Trace, [core.String]),
|
||||
parseSafari6_0: dart.definiteFunctionType(src__trace.Trace, [core.String]),
|
||||
parseFriendly: dart.definiteFunctionType(src__trace.Trace, [core.String]),
|
||||
new: dart.definiteFunctionType(src__trace.Trace, [core.Iterable$(src__frame.Frame)])
|
||||
}),
|
||||
methods: () => ({foldFrames: dart.definiteFunctionType(src__trace.Trace, [dart.functionType(core.bool, [src__frame.Frame])], {terse: core.bool})}),
|
||||
statics: () => ({
|
||||
format: dart.definiteFunctionType(core.String, [core.StackTrace], {terse: core.bool}),
|
||||
_parseVM: dart.definiteFunctionType(core.List$(src__frame.Frame), [core.String])
|
||||
}),
|
||||
names: ['format', '_parseVM']
|
||||
});
|
||||
src__unparsed_frame.UnparsedFrame = class UnparsedFrame extends core.Object {
|
||||
new(member) {
|
||||
this.uri = core.Uri.new({path: "unparsed"});
|
||||
this.member = member;
|
||||
this.line = null;
|
||||
this.column = null;
|
||||
this.isCore = false;
|
||||
this.library = "unparsed";
|
||||
this.package = null;
|
||||
this.location = "unparsed";
|
||||
}
|
||||
toString() {
|
||||
return this.member;
|
||||
}
|
||||
};
|
||||
src__unparsed_frame.UnparsedFrame[dart.implements] = () => [src__frame.Frame];
|
||||
dart.setSignature(src__unparsed_frame.UnparsedFrame, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(src__unparsed_frame.UnparsedFrame, [core.String])})
|
||||
});
|
||||
src__utils.chainGap = '===== asynchronous gap ===========================\n';
|
||||
dart.defineLazy(src__utils, {
|
||||
get inJS() {
|
||||
return dart.equals(path$.style, src__style.Style.url);
|
||||
}
|
||||
});
|
||||
src__utils.padRight = function(string, length) {
|
||||
if (dart.notNull(string[dartx.length]) >= dart.notNull(length)) return string;
|
||||
let result = new core.StringBuffer();
|
||||
result.write(string);
|
||||
for (let i = 0; i < dart.notNull(length) - dart.notNull(string[dartx.length]); i++) {
|
||||
result.write(' ');
|
||||
}
|
||||
return result.toString();
|
||||
};
|
||||
dart.fn(src__utils.padRight, StringAndintToString());
|
||||
src__vm_trace.VMTrace = class VMTrace extends core.Object {
|
||||
new(frames) {
|
||||
this.frames = frames;
|
||||
}
|
||||
toString() {
|
||||
let i = 1;
|
||||
return this.frames[dartx.map](core.String)(dart.fn(frame => {
|
||||
let number = src__utils.padRight(dart.str`#${i++}`, 8);
|
||||
let member = frame.member[dartx.replaceAllMapped](core.RegExp.new("[^.]+\\.<async>"), dart.fn(match => dart.str`${match.get(1)}.<${match.get(1)}_async_body>`, MatchToString()))[dartx.replaceAll]("<fn>", "<anonymous closure>");
|
||||
let line = frame.line == null ? 0 : frame.line;
|
||||
let column = frame.column == null ? 0 : frame.column;
|
||||
return dart.str`${number}${member} (${frame.uri}:${line}:${column})\n`;
|
||||
}, FrameToString()))[dartx.join]();
|
||||
}
|
||||
};
|
||||
src__vm_trace.VMTrace[dart.implements] = () => [core.StackTrace];
|
||||
dart.setSignature(src__vm_trace.VMTrace, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(src__vm_trace.VMTrace, [core.List$(src__frame.Frame)])})
|
||||
});
|
||||
stack_trace.ChainHandler = src__chain.ChainHandler;
|
||||
stack_trace.Chain = src__chain.Chain;
|
||||
stack_trace.Frame = src__frame.Frame;
|
||||
stack_trace.Trace = src__trace.Trace;
|
||||
stack_trace.UnparsedFrame = src__unparsed_frame.UnparsedFrame;
|
||||
// Exports:
|
||||
exports.src__chain = src__chain;
|
||||
exports.src__frame = src__frame;
|
||||
exports.src__lazy_trace = src__lazy_trace;
|
||||
exports.src__stack_zone_specification = src__stack_zone_specification;
|
||||
exports.src__trace = src__trace;
|
||||
exports.src__unparsed_frame = src__unparsed_frame;
|
||||
exports.src__utils = src__utils;
|
||||
exports.src__vm_trace = src__vm_trace;
|
||||
exports.stack_trace = stack_trace;
|
||||
});
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -6,7 +6,9 @@ dart_library.library('varargs', null, /* Imports */[
|
|||
const dart = dart_sdk.dart;
|
||||
const dartx = dart_sdk.dartx;
|
||||
const varargs = Object.create(null);
|
||||
const src__varargs = Object.create(null);
|
||||
let dynamicAnddynamicTodynamic = () => (dynamicAnddynamicTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [dart.dynamic, dart.dynamic])))();
|
||||
let dynamicTodynamic = () => (dynamicTodynamic = dart.constFn(dart.definiteFunctionType(dart.dynamic, [dart.dynamic])))();
|
||||
varargs.varargsTest = function(x, ...others) {
|
||||
let args = [1, others];
|
||||
dart.dsend(x, 'call', ...args);
|
||||
|
|
@ -17,6 +19,19 @@ dart_library.library('varargs', null, /* Imports */[
|
|||
dart.dsend(x, 'call', ...args);
|
||||
};
|
||||
dart.fn(varargs.varargsTest2, dynamicAnddynamicTodynamic());
|
||||
src__varargs._Rest = class _Rest extends core.Object {
|
||||
new() {
|
||||
}
|
||||
};
|
||||
dart.setSignature(src__varargs._Rest, {
|
||||
constructors: () => ({new: dart.definiteFunctionType(src__varargs._Rest, [])})
|
||||
});
|
||||
src__varargs.rest = dart.const(new src__varargs._Rest());
|
||||
src__varargs.spread = function(args) {
|
||||
dart.throw(new core.StateError('The spread function cannot be called, ' + 'it should be compiled away.'));
|
||||
};
|
||||
dart.fn(src__varargs.spread, dynamicTodynamic());
|
||||
// Exports:
|
||||
exports.varargs = varargs;
|
||||
exports.src__varargs = src__varargs;
|
||||
});
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ import 'dart:convert' show JSON;
|
|||
import 'dart:io' show Directory, File, Platform;
|
||||
import 'package:args/args.dart' show ArgParser, ArgResults;
|
||||
import 'package:path/path.dart' as path;
|
||||
import 'package:test/test.dart' show group, test;
|
||||
import 'package:test/test.dart' show test;
|
||||
|
||||
import 'package:analyzer/analyzer.dart'
|
||||
show
|
||||
|
|
@ -56,14 +56,6 @@ final codegenTestDir = path.join(repoDirectory, 'gen', 'codegen_tests');
|
|||
/// output.
|
||||
final codegenOutputDir = path.join(repoDirectory, 'gen', 'codegen_output');
|
||||
|
||||
// TODO(jmesserly): switch this to a .packages file.
|
||||
final packageUrlMappings = {
|
||||
'package:expect/expect.dart': path.join(codegenDir, 'expect.dart'),
|
||||
'package:async_helper/async_helper.dart':
|
||||
path.join(codegenDir, 'async_helper.dart'),
|
||||
'package:js/js.dart': path.join(codegenDir, 'packages', 'js', 'js.dart')
|
||||
};
|
||||
|
||||
final codeCoverage = Platform.environment.containsKey('COVERALLS_TOKEN');
|
||||
|
||||
RegExp filePattern;
|
||||
|
|
@ -76,13 +68,16 @@ main(List<String> arguments) {
|
|||
var sdkDir = path.join(repoDirectory, 'gen', 'patched_sdk');
|
||||
var sdkSummaryFile =
|
||||
path.join(testDirectory, '..', 'lib', 'runtime', 'dart_sdk.sum');
|
||||
var analyzerOptions = new AnalyzerOptions(
|
||||
customUrlMappings: packageUrlMappings,
|
||||
dartSdkSummaryPath: sdkSummaryFile);
|
||||
var compiler = new ModuleCompiler(analyzerOptions);
|
||||
|
||||
// Build packages tests depend on.
|
||||
_buildAllPackages(compiler);
|
||||
var summaryPaths = new Directory(path.join(codegenOutputDir, 'pkg'))
|
||||
.listSync()
|
||||
.map((e) => e.path)
|
||||
.where((p) => p.endsWith('.sum'))
|
||||
.toList();
|
||||
|
||||
var analyzerOptions = new AnalyzerOptions(
|
||||
dartSdkSummaryPath: sdkSummaryFile, summaryPaths: summaryPaths);
|
||||
var compiler = new ModuleCompiler(analyzerOptions);
|
||||
|
||||
var testDirs = [
|
||||
'language',
|
||||
|
|
@ -141,6 +136,10 @@ main(List<String> arguments) {
|
|||
});
|
||||
}
|
||||
|
||||
if (filePattern.hasMatch('sunflower')) {
|
||||
_buildSunflower(compiler, codegenOutputDir, codegenExpectDir);
|
||||
}
|
||||
|
||||
if (codeCoverage) {
|
||||
test('build_sdk code coverage', () {
|
||||
return build_sdk.main(['--dart-sdk', sdkDir, '-o', codegenOutputDir]);
|
||||
|
|
@ -157,11 +156,15 @@ void _writeModule(String outPath, String expectPath, JSModuleFile result) {
|
|||
new File(outPath + '.txt').writeAsStringSync(errors);
|
||||
|
||||
var jsFile = new File(outPath + '.js');
|
||||
var summaryFile = new File(outPath + '.sum');
|
||||
var expectFile = new File(expectPath + '.js');
|
||||
var errorFile = new File(outPath + '.err');
|
||||
|
||||
if (result.isValid) {
|
||||
jsFile.writeAsStringSync(result.code);
|
||||
if (result.summaryBytes != null) {
|
||||
summaryFile.writeAsBytesSync(result.summaryBytes);
|
||||
}
|
||||
if (result.sourceMap != null) {
|
||||
var mapPath = outPath + '.js.map';
|
||||
new File(mapPath)
|
||||
|
|
@ -207,40 +210,6 @@ dart_library.library('$moduleName', null, [
|
|||
}
|
||||
}
|
||||
|
||||
void _buildAllPackages(ModuleCompiler compiler) {
|
||||
group('dartdevc package', () {
|
||||
_buildPackages(compiler, codegenOutputDir, codegenExpectDir);
|
||||
|
||||
var packages = ['matcher', 'path', 'stack_trace'];
|
||||
for (var package in packages) {
|
||||
if (!filePattern.hasMatch(package)) continue;
|
||||
test(package, () {
|
||||
_buildPackage(compiler, codegenOutputDir, codegenExpectDir, package);
|
||||
});
|
||||
}
|
||||
|
||||
if (!filePattern.hasMatch('unittest')) return;
|
||||
|
||||
test('unittest', () {
|
||||
// Only build files applicable to the web - html_*.dart and its
|
||||
// internal dependences.
|
||||
_buildPackage(compiler, codegenOutputDir, codegenExpectDir, "unittest",
|
||||
packageFiles: [
|
||||
'unittest.dart',
|
||||
'html_config.dart',
|
||||
'html_individual_config.dart',
|
||||
'html_enhanced_config.dart'
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
if (!filePattern.hasMatch('sunflower')) return;
|
||||
|
||||
test('dartdevc sunflower', () {
|
||||
_buildSunflower(compiler, codegenOutputDir, codegenExpectDir);
|
||||
});
|
||||
}
|
||||
|
||||
void _buildSunflower(
|
||||
ModuleCompiler compiler, String outputDir, String expectDir) {
|
||||
var baseDir = path.join(codegenDir, 'sunflower');
|
||||
|
|
@ -255,65 +224,6 @@ void _buildSunflower(
|
|||
path.join(expectDir, 'sunflower', 'sunflower'), built);
|
||||
}
|
||||
|
||||
void _buildPackages(
|
||||
ModuleCompiler compiler, String outputDir, String expectDir) {
|
||||
// Note: we don't summarize these, as we're going to rely on our in-memory
|
||||
// shared analysis context for caching, and `_moduleForLibrary` below
|
||||
// understands these are from other modules.
|
||||
var options = new CompilerOptions(sourceMap: false, summarizeApi: false);
|
||||
|
||||
for (var uri in packageUrlMappings.keys) {
|
||||
if (!filePattern.hasMatch(uri)) return;
|
||||
|
||||
assert(uri.startsWith('package:'));
|
||||
var uriPath = uri.substring('package:'.length);
|
||||
var name = path.basenameWithoutExtension(uriPath);
|
||||
test(name, () {
|
||||
var input = new BuildUnit(name, codegenDir, [uri], _moduleForLibrary);
|
||||
var built = compiler.compile(input, options);
|
||||
|
||||
var outPath = path.join(outputDir, path.withoutExtension(uriPath));
|
||||
var expectPath = path.join(expectDir, path.withoutExtension(uriPath));
|
||||
_writeModule(outPath, expectPath, built);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
void _buildPackage(
|
||||
ModuleCompiler compiler, String outputDir, String expectDir, packageName,
|
||||
{List<String> packageFiles}) {
|
||||
var options = new CompilerOptions(sourceMap: false, summarizeApi: false);
|
||||
|
||||
var packageRoot = path.join(codegenDir, 'packages');
|
||||
var packageInputDir = path.join(packageRoot, packageName);
|
||||
List<String> files;
|
||||
if (packageFiles != null) {
|
||||
// Only collect files transitively reachable from packageFiles.
|
||||
var reachable = new Set<String>();
|
||||
for (var file in packageFiles) {
|
||||
file = path.join(packageInputDir, file);
|
||||
_collectTransitiveImports(new File(file).readAsStringSync(), reachable,
|
||||
packageRoot: packageRoot, from: file);
|
||||
}
|
||||
files = reachable.toList();
|
||||
} else {
|
||||
// Collect all files in the packages directory.
|
||||
files = new Directory(packageInputDir)
|
||||
.listSync(recursive: true)
|
||||
.where((entry) => entry.path.endsWith('.dart'))
|
||||
.map((entry) => entry.path)
|
||||
.toList();
|
||||
}
|
||||
|
||||
var unit =
|
||||
new BuildUnit(packageName, packageInputDir, files, _moduleForLibrary);
|
||||
var module = compiler.compile(unit, options);
|
||||
|
||||
var outPath = path.join(outputDir, packageName, packageName);
|
||||
var expectPath = path.join(expectDir, packageName, packageName);
|
||||
_writeModule(outPath, expectPath, module);
|
||||
}
|
||||
|
||||
String _moduleForLibrary(Source source) {
|
||||
var scheme = source.uri.scheme;
|
||||
if (scheme == 'package') {
|
||||
|
|
|
|||
|
|
@ -12,9 +12,6 @@ import 'package:bazel_worker/src/async_message_grouper.dart';
|
|||
import 'package:bazel_worker/testing.dart';
|
||||
import 'package:test/test.dart';
|
||||
|
||||
import 'package:dev_compiler/src/compiler/compiler.dart'
|
||||
show missingPartErrorCode, unusedPartWarningCode;
|
||||
|
||||
main() {
|
||||
group('Hello World', () {
|
||||
final argsFile = new File('test/worker/hello_world.args').absolute;
|
||||
|
|
@ -222,7 +219,7 @@ main() {
|
|||
expect(outJS.existsSync(), isTrue);
|
||||
});
|
||||
|
||||
test('error if part is not supplied', () {
|
||||
test('works if part is not supplied', () {
|
||||
var result = Process.runSync('dart', [
|
||||
'bin/dartdevc.dart',
|
||||
'compile',
|
||||
|
|
@ -232,16 +229,13 @@ main() {
|
|||
outJS.path,
|
||||
libraryFile.path,
|
||||
]);
|
||||
expect(
|
||||
result.stdout,
|
||||
startsWith('[error] ${missingPartErrorCode.message} '
|
||||
'(test/worker/greeting.dart, line 1, col 1)'));
|
||||
expect(result.stdout, isEmpty);
|
||||
expect(result.stderr, isEmpty);
|
||||
expect(result.exitCode, 1);
|
||||
expect(outJS.existsSync(), isFalse);
|
||||
expect(result.exitCode, 0);
|
||||
expect(outJS.existsSync(), isTrue);
|
||||
});
|
||||
|
||||
test('warning if part without library is supplied', () {
|
||||
test('part without library is silently ignored', () {
|
||||
var result = Process.runSync('dart', [
|
||||
'bin/dartdevc.dart',
|
||||
'compile',
|
||||
|
|
@ -251,10 +245,7 @@ main() {
|
|||
outJS.path,
|
||||
partFile.path,
|
||||
]);
|
||||
expect(
|
||||
result.stdout,
|
||||
startsWith('[warning] ${unusedPartWarningCode.message} '
|
||||
'(test/worker/greeting.dart, line 1, col 1)'));
|
||||
expect(result.stdout, isEmpty);
|
||||
expect(result.stderr, isEmpty);
|
||||
expect(result.exitCode, 0);
|
||||
expect(outJS.existsSync(), isTrue);
|
||||
|
|
|
|||
34
pkg/dev_compiler/tool/build_test_pkgs.sh
Executable file
34
pkg/dev_compiler/tool/build_test_pkgs.sh
Executable file
|
|
@ -0,0 +1,34 @@
|
|||
#!/bin/bash
|
||||
set -e # bail on error
|
||||
|
||||
cd $( dirname "${BASH_SOURCE[0]}" )/..
|
||||
|
||||
mkdir -p gen/codegen_output/pkg/
|
||||
|
||||
SDK=--dart-sdk-summary=lib/runtime/dart_sdk.sum
|
||||
|
||||
./bin/dartdevc.dart $SDK -o gen/codegen_output/pkg/expect.js \
|
||||
--url-mapping=package:expect/expect.dart,test/codegen/expect.dart \
|
||||
package:expect/expect.dart
|
||||
|
||||
./bin/dartdevc.dart $SDK -o gen/codegen_output/pkg/async_helper.js \
|
||||
--url-mapping=package:async_helper/async_helper.dart,test/codegen/async_helper.dart \
|
||||
package:async_helper/async_helper.dart
|
||||
|
||||
./bin/dartdevc.dart $SDK -o gen/codegen_output/pkg/js.js \
|
||||
package:js/js.dart
|
||||
|
||||
./bin/dartdevc.dart $SDK -o gen/codegen_output/pkg/matcher.js \
|
||||
package:matcher/matcher.dart
|
||||
|
||||
./bin/dartdevc.dart $SDK -o gen/codegen_output/pkg/stack_trace.js \
|
||||
package:stack_trace/stack_trace.dart
|
||||
|
||||
./bin/dartdevc.dart $SDK -o gen/codegen_output/pkg/path.js \
|
||||
package:path/path.dart
|
||||
|
||||
./bin/dartdevc.dart $SDK -o gen/codegen_output/pkg/unittest.js \
|
||||
package:unittest/unittest.dart \
|
||||
package:unittest/html_config.dart \
|
||||
package:unittest/html_individual_config.dart \
|
||||
package:unittest/html_enhanced_config.dart
|
||||
|
|
@ -20,12 +20,6 @@
|
|||
[error] Invalid override. The type of _SpeechRecognitionResultList.[]= ((int, SpeechRecognitionResult) → void) is not a subtype of JSMutableIndexable.[]= ((int, dynamic) → dynamic). (dart:html, line 38351, col 3)
|
||||
[error] Invalid override. The type of _StyleSheetList.[]= ((int, StyleSheet) → void) is not a subtype of JSMutableIndexable.[]= ((int, dynamic) → dynamic). (dart:html, line 38415, col 3)
|
||||
[error] Invalid override. The type of _EventStreamSubscription.asFuture (([dynamic]) → Future<dynamic>) is not a subtype of StreamSubscription<T>.asFuture (<E>([E]) → Future<E>). (dart:html, line 40152, col 3)
|
||||
[error] The part was not supplied as an input to the compiler. (dart:html_common/conversions.dart, line 1, col 1)
|
||||
[error] The part was not supplied as an input to the compiler. (dart:html_common/conversions_dart2js.dart, line 1, col 1)
|
||||
[error] The part was not supplied as an input to the compiler. (dart:html_common/css_class_set.dart, line 1, col 1)
|
||||
[error] The part was not supplied as an input to the compiler. (dart:html_common/device.dart, line 1, col 1)
|
||||
[error] The part was not supplied as an input to the compiler. (dart:html_common/filtered_element_list.dart, line 1, col 1)
|
||||
[error] The part was not supplied as an input to the compiler. (dart:html_common/lists.dart, line 1, col 1)
|
||||
[error] Invalid override. The type of JsArray.[]= ((Object, E) → void) is not a subtype of JsObject.[]= ((Object, dynamic) → dynamic). (dart:js, line 363, col 3)
|
||||
[error] The return type 'double' is not a 'T', as defined by the method 'min'. (dart:math, line 90, col 16)
|
||||
[error] The return type 'double' is not a 'T', as defined by the method 'min'. (dart:math, line 94, col 51)
|
||||
|
|
|
|||
|
|
@ -27,6 +27,8 @@ if [ -d gen/codegen_output ]; then
|
|||
rm -r gen/codegen_output || fail
|
||||
fi
|
||||
|
||||
./tool/build_test_pkgs.sh
|
||||
|
||||
# Make sure we don't run tests in code coverage mode.
|
||||
# this will cause us to generate files that are not part of the baseline
|
||||
# TODO(jmesserly): we should move diff into Dart code, so we don't need to
|
||||
|
|
|
|||
Loading…
Reference in a new issue