Version 1.21.0-dev.2.0
Merge 057b9ceba75a7fe60d2986ce02b7dba3e7cc459f into dev
diff --git a/.travis.yml b/.travis.yml
index f6c7f53..246ca09 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -80,6 +80,7 @@
matrix:
allow_failures:
- env: TEST=node
+ - env: ANALYZER=master DDC_BROWSERS=ChromeCanaryTravis
- env: ANALYZER=master DDC_BROWSERS=Firefox
- env: ANALYZER=master CXX=g++
notifications:
diff --git a/BUILD.gn b/BUILD.gn
index da04aef..a7d7e22 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -57,6 +57,7 @@
"runtime/bin:dart",
"utils/analysis_server",
"utils/compiler:dart2js",
+ "utils/compiler:utils_wrapper",
"utils/dartanalyzer:generate_dartanalyzer_snapshot",
"utils/dartanalyzer:generate_summary_spec",
"utils/dartanalyzer:generate_summary_strong",
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f561166..69f85c2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
## 1.21.0
+### Core library changes
+
+* `dart:core`: `Set.difference` now takes a `Set<Object>` as argument.
### Language
diff --git a/DEPS b/DEPS
index c3db0eb..a9a71fb 100644
--- a/DEPS
+++ b/DEPS
@@ -56,7 +56,7 @@
"csslib_tag" : "@0.13.2",
"dart2js_info_tag" : "@0.5.0",
"dart_services_rev" : "@7aea2574e6f3924bf409a80afb8ad52aa2be4f97",
- "dart_style_tag": "@0.2.10",
+ "dart_style_tag": "@v0.2.11+1",
"dartdoc_tag" : "@v0.9.7+6",
"fixnum_tag": "@0.10.5",
"func_tag": "@0.1.0",
diff --git a/build/config/compiler/BUILD.gn b/build/config/compiler/BUILD.gn
index a2f8b13..873dc4c 100644
--- a/build/config/compiler/BUILD.gn
+++ b/build/config/compiler/BUILD.gn
@@ -732,10 +732,11 @@
# Turn off optimizations.
config("no_optimize") {
if (is_win) {
+ # The only difference on windows is that the inlining is less aggressive.
+ # (We accept the default level). Otherwise it is very slow.
cflags = [
"/O2", # Do some optimizations.
"/Oy-", # Disable omitting frame pointers, must be after /O2.
- "/Ob0", # Disable all inlining (on by default).
]
} else if (is_android) {
# On Android we kind of optimize some things that don't affect debugging
diff --git a/pkg/analysis_server/lib/src/analysis_server.dart b/pkg/analysis_server/lib/src/analysis_server.dart
index ae1bb0a..fdef53a 100644
--- a/pkg/analysis_server/lib/src/analysis_server.dart
+++ b/pkg/analysis_server/lib/src/analysis_server.dart
@@ -1645,16 +1645,18 @@
}
}
+ ContextBuilderOptions builderOptions = new ContextBuilderOptions();
+ builderOptions.defaultOptions = options;
+ builderOptions.defaultPackageFilePath = defaultPackageFilePath;
+ builderOptions.defaultPackagesDirectoryPath = defaultPackagesDirectoryPath;
+ if (analysisServer.options.enablePubSummaryManager) {
+ builderOptions.pubSummaryManager = analysisServer.pubSummaryManager;
+ }
ContextBuilder builder = new ContextBuilder(resourceProvider,
- analysisServer.sdkManager, analysisServer.overlayState);
- builder.defaultOptions = options;
+ analysisServer.sdkManager, analysisServer.overlayState,
+ options: builderOptions);
builder.fileResolverProvider = analysisServer.fileResolverProvider;
builder.packageResolverProvider = analysisServer.packageResolverProvider;
- builder.defaultPackageFilePath = defaultPackageFilePath;
- builder.defaultPackagesDirectoryPath = defaultPackagesDirectoryPath;
- if (analysisServer.options.enablePubSummaryManager) {
- builder.pubSummaryManager = analysisServer.pubSummaryManager;
- }
return builder;
}
diff --git a/pkg/analysis_server/test/context_manager_test.dart b/pkg/analysis_server/test/context_manager_test.dart
index 46414f6..888c2dd 100644
--- a/pkg/analysis_server/test/context_manager_test.dart
+++ b/pkg/analysis_server/test/context_manager_test.dart
@@ -2707,9 +2707,11 @@
@override
ContextBuilder createContextBuilder(Folder folder, AnalysisOptions options) {
DartSdkManager sdkManager = new DartSdkManager('/', false);
- ContextBuilder builder =
- new ContextBuilder(resourceProvider, sdkManager, new ContentCache());
- builder.defaultOptions = options;
+ ContextBuilderOptions builderOptions = new ContextBuilderOptions();
+ builderOptions.defaultOptions = options;
+ ContextBuilder builder = new ContextBuilder(
+ resourceProvider, sdkManager, new ContentCache(),
+ options: builderOptions);
return builder;
}
diff --git a/pkg/analyzer/lib/error/error.dart b/pkg/analyzer/lib/error/error.dart
index 2db4525..49c0179 100644
--- a/pkg/analyzer/lib/error/error.dart
+++ b/pkg/analyzer/lib/error/error.dart
@@ -298,7 +298,14 @@
// Manually generated. You can mostly reproduce this list by running the
// following command from the root of the analyzer package:
//
- // > cat lib/src/dart/error/syntactic_errors.dart src/error/codes.dart |
+ // > cat
+ // lib/src/analysis_options/error/option_codes.dart';
+ // lib/src/dart/error/hint_codes.dart';
+ // lib/src/dart/error/lint_codes.dart';
+ // lib/src/dart/error/todo_codes.dart';
+ // lib/src/html/error/html_codes.dart';
+ // lib/src/dart/error/syntactic_errors.dart
+ // lib/src/error/codes.dart |
// grep 'static const .*Code' |
// awk '{print $3"."$4","}' |
// sort > codes.txt
@@ -350,7 +357,8 @@
CompileTimeErrorCode.CONST_EVAL_TYPE_NUM,
CompileTimeErrorCode.CONST_FORMAL_PARAMETER,
CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE,
- CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY,
+ CompileTimeErrorCode
+ .CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY,
CompileTimeErrorCode.CONST_INSTANCE_FIELD,
CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS,
CompileTimeErrorCode.CONST_NOT_INITIALIZED,
@@ -444,7 +452,8 @@
CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE,
CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY,
CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER,
- CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY,
+ CompileTimeErrorCode
+ .NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY,
CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT,
CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR,
CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS,
diff --git a/pkg/analyzer/lib/src/analysis_options/error/option_codes.dart b/pkg/analyzer/lib/src/analysis_options/error/option_codes.dart
new file mode 100644
index 0000000..4b39a45
--- /dev/null
+++ b/pkg/analyzer/lib/src/analysis_options/error/option_codes.dart
@@ -0,0 +1,114 @@
+// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library analyzer.src.analysis_options.error.option_codes;
+
+import 'package:analyzer/error/error.dart';
+
+/**
+ * The error codes used for errors in analysis options files. The convention for
+ * this class is for the name of the error code to indicate the problem that
+ * caused the error to be generated and for the error message to explain what is
+ * wrong and, when appropriate, how the problem can be corrected.
+ */
+class AnalysisOptionsErrorCode extends ErrorCode {
+ /**
+ * An error code indicating that there is a syntactic error in the file.
+ *
+ * Parameters:
+ * 0: the error message from the parse error
+ */
+ static const AnalysisOptionsErrorCode PARSE_ERROR =
+ const AnalysisOptionsErrorCode('PARSE_ERROR', '{0}');
+
+ /**
+ * Initialize a newly created error code to have the given [name].
+ */
+ const AnalysisOptionsErrorCode(String name, String message,
+ [String correction])
+ : super(name, message, correction);
+
+ @override
+ ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
+
+ @override
+ ErrorType get type => ErrorType.COMPILE_TIME_ERROR;
+}
+
+/**
+ * The error codes used for warnings in analysis options files. The convention
+ * for this class is for the name of the error code to indicate the problem that
+ * caused the error to be generated and for the error message to explain what is
+ * wrong and, when appropriate, how the problem can be corrected.
+ */
+class AnalysisOptionsWarningCode extends ErrorCode {
+ /**
+ * An error code indicating that a plugin is being configured with an
+ * unsupported option and legal options are provided.
+ *
+ * Parameters:
+ * 0: the plugin name
+ * 1: the unsupported option key
+ * 2: legal values
+ */
+ static const AnalysisOptionsWarningCode UNSUPPORTED_OPTION_WITH_LEGAL_VALUES =
+ const AnalysisOptionsWarningCode(
+ 'UNSUPPORTED_OPTION_WITH_LEGAL_VALUES',
+ "The option '{1}' isn't supported by '{0}'.",
+ "Try using one of the supported options: {2}.");
+
+ /**
+ * An error code indicating that a plugin is being configured with an
+ * unsupported option where there is just one legal value.
+ *
+ * Parameters:
+ * 0: the plugin name
+ * 1: the unsupported option key
+ * 2: the legal value
+ */
+ static const AnalysisOptionsWarningCode UNSUPPORTED_OPTION_WITH_LEGAL_VALUE =
+ const AnalysisOptionsWarningCode(
+ 'UNSUPPORTED_OPTION_WITH_LEGAL_VALUE',
+ "The option '{1}' isn't supported by '{0}'."
+ "Try using the only supported option: '{2}'.");
+
+ /**
+ * An error code indicating that an option entry is being configured with an
+ * unsupported value.
+ *
+ * Parameters:
+ * 0: the option name
+ * 1: the unsupported value
+ * 2: legal values
+ */
+ static const AnalysisOptionsWarningCode UNSUPPORTED_VALUE =
+ const AnalysisOptionsWarningCode(
+ 'UNSUPPORTED_VALUE',
+ "The value '{1}' isn't supported by '{0}'.",
+ "Try using one of the supported options: {2}.");
+
+ /**
+ * An error code indicating that an unrecognized error code is being used to
+ * specify an error filter.
+ *
+ * Parameters:
+ * 0: the unrecognized error code
+ */
+ static const AnalysisOptionsWarningCode UNRECOGNIZED_ERROR_CODE =
+ const AnalysisOptionsWarningCode(
+ 'UNRECOGNIZED_ERROR_CODE', "'{0}' isn't a recognized error code.");
+
+ /**
+ * Initialize a newly created warning code to have the given [name].
+ */
+ const AnalysisOptionsWarningCode(String name, String message,
+ [String correction])
+ : super(name, message, correction);
+
+ @override
+ ErrorSeverity get errorSeverity => ErrorSeverity.WARNING;
+
+ @override
+ ErrorType get type => ErrorType.STATIC_WARNING;
+}
diff --git a/pkg/analyzer/lib/src/command_line/arguments.dart b/pkg/analyzer/lib/src/command_line/arguments.dart
new file mode 100644
index 0000000..147ade7
--- /dev/null
+++ b/pkg/analyzer/lib/src/command_line/arguments.dart
@@ -0,0 +1,256 @@
+// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library analyzer.src.command_line.arguments;
+
+import 'dart:collection';
+
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/src/context/builder.dart';
+import 'package:analyzer/src/dart/sdk/sdk.dart';
+import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/sdk.dart';
+import 'package:args/args.dart';
+import 'package:path/path.dart';
+
+const String analysisOptionsFileOption = 'options';
+const String defineVariableOption = 'D';
+const String enableInitializingFormalAccessFlag = 'initializing-formal-access';
+const String enableStrictCallChecksFlag = 'enable-strict-call-checks';
+const String enableSuperInMixinFlag = 'supermixin';
+const String ignoreUnrecognizedFlagsFlag = 'ignore_unrecognized_flags';
+const String noImplicitCastsFlag = 'no-implicit-casts';
+const String noImplicitDynamicFlag = 'no-implicit-dynamic';
+const String packageRootOption = 'package-root';
+const String packagesOption = 'packages';
+const String sdkPathOption = 'dart-sdk';
+const String sdkSummaryPathOption = 'dart-sdk-summary';
+const String strongModeFlag = 'strong';
+
+/**
+ * Use the given [resourceProvider], [contentCache] and command-line [args] to
+ * create a context builder.
+ */
+ContextBuilderOptions createContextBuilderOptions(ArgResults args) {
+ ContextBuilderOptions builderOptions = new ContextBuilderOptions();
+ //
+ // File locations.
+ //
+ builderOptions.dartSdkSummaryPath = args[sdkSummaryPathOption];
+ builderOptions.defaultAnalysisOptionsFilePath =
+ args[analysisOptionsFileOption];
+ builderOptions.defaultPackageFilePath = args[packagesOption];
+ builderOptions.defaultPackagesDirectoryPath = args[packageRootOption];
+ //
+ // Analysis options.
+ //
+ AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
+ defaultOptions.enableInitializingFormalAccess =
+ args[enableInitializingFormalAccessFlag];
+ defaultOptions.enableStrictCallChecks = args[enableStrictCallChecksFlag];
+ defaultOptions.enableSuperMixins = args[enableSuperInMixinFlag];
+ defaultOptions.implicitCasts = !args[noImplicitCastsFlag];
+ defaultOptions.implicitDynamic = !args[noImplicitDynamicFlag];
+ defaultOptions.strongMode = args[strongModeFlag];
+ builderOptions.defaultOptions = defaultOptions;
+ //
+ // Declared variables.
+ //
+ Map<String, String> declaredVariables = <String, String>{};
+ List<String> variables = args[defineVariableOption] as List<String>;
+ for (String variable in variables) {
+ int index = variable.indexOf('=');
+ if (index < 0) {
+ // TODO (brianwilkerson) Decide the semantics we want in this case.
+ // The VM prints "No value given to -D option", then tries to load '-Dfoo'
+ // as a file and dies. Unless there was nothing after the '-D', in which
+ // case it prints the warning and ignores the option.
+ } else {
+ String name = variable.substring(0, index);
+ if (name.isNotEmpty) {
+ // TODO (brianwilkerson) Decide the semantics we want in the case where
+ // there is no name. If there is no name, the VM tries to load a file
+ // named '-D' and dies.
+ declaredVariables[name] = variable.substring(index + 1);
+ }
+ }
+ }
+ builderOptions.declaredVariables = declaredVariables;
+
+ return builderOptions;
+}
+
+/**
+ * Use the given [resourceProvider] and command-line [args] to create a Dart SDK
+ * manager. The manager will use summary information if [useSummaries] is `true`
+ * and if the summary information exists.
+ */
+DartSdkManager createDartSdkManager(
+ ResourceProvider resourceProvider, bool useSummaries, ArgResults args) {
+ String sdkPath = args[sdkPathOption];
+
+ bool canUseSummaries = useSummaries &&
+ args.rest.every((String sourcePath) {
+ sourcePath = context.absolute(sourcePath);
+ sourcePath = context.normalize(sourcePath);
+ return !context.isWithin(sdkPath, sourcePath);
+ });
+ return new DartSdkManager(
+ sdkPath ?? FolderBasedDartSdk.defaultSdkDirectory(resourceProvider),
+ canUseSummaries);
+}
+
+/**
+ * Add the standard flags and options to the given [parser]. The standard flags
+ * are those that are typically used to control the way in which the code is
+ * analyzed.
+ */
+void defineAnalysisArguments(ArgParser parser) {
+ parser.addOption(defineVariableOption,
+ abbr: 'D',
+ allowMultiple: true,
+ help: 'Define environment variables. For example, "-Dfoo=bar" defines an '
+ 'environment variable named "foo" whose value is "bar".');
+ parser.addOption(sdkPathOption, help: 'The path to the Dart SDK.');
+ parser.addOption(sdkSummaryPathOption,
+ help: 'The path to the Dart SDK summary file.', hide: true);
+ parser.addOption(analysisOptionsFileOption,
+ help: 'Path to an analysis options file.');
+ parser.addOption(packagesOption,
+ help: 'The path to the package resolution configuration file, which '
+ 'supplies a mapping of package names to paths. This option cannot be '
+ 'used with --package-root.');
+ parser.addOption(packageRootOption,
+ abbr: 'p',
+ help: 'The path to a package root directory (deprecated). This option '
+ 'cannot be used with --packages.');
+
+ parser.addFlag(strongModeFlag,
+ help: 'Enable strong static checks (https://goo.gl/DqcBsw)');
+ parser.addFlag(noImplicitCastsFlag,
+ negatable: false,
+ help: 'Disable implicit casts in strong mode (https://goo.gl/cTLz40)');
+ parser.addFlag(noImplicitDynamicFlag,
+ negatable: false,
+ help: 'Disable implicit dynamic (https://goo.gl/m0UgXD)');
+ //
+ // Hidden flags and options.
+ //
+// parser.addFlag(enableNullAwareOperatorsFlag, // 'enable-null-aware-operators'
+// help: 'Enable support for null-aware operators (DEP 9).',
+// defaultsTo: false,
+// negatable: false,
+// hide: true);
+ parser.addFlag(enableStrictCallChecksFlag,
+ help: 'Fix issue 21938.',
+ defaultsTo: false,
+ negatable: false,
+ hide: true);
+ parser.addFlag(enableInitializingFormalAccessFlag,
+ help:
+ 'Enable support for allowing access to field formal parameters in a '
+ 'constructor\'s initializer list',
+ defaultsTo: false,
+ negatable: false,
+ hide: true);
+ parser.addFlag(enableSuperInMixinFlag,
+ help: 'Relax restrictions on mixins (DEP 34).',
+ defaultsTo: false,
+ negatable: false,
+ hide: true);
+// parser.addFlag('enable_type_checks',
+// help: 'Check types in constant evaluation.',
+// defaultsTo: false,
+// negatable: false,
+// hide: true);
+}
+
+/**
+ * Return a list of command-line arguments containing all of the given [args]
+ * that are defined by the given [parser]. An argument is considered to be
+ * defined by the parser if
+ * - it starts with '--' and the rest of the argument (minus any value
+ * introduced by '=') is the name of a known option,
+ * - it starts with '-' and the rest of the argument (minus any value
+ * introduced by '=') is the name of a known abbreviation, or
+ * - it starts with something other than '--' or '-'.
+ *
+ * This function allows command-line tools to implement the
+ * '--ignore_unrecognized_flags' option.
+ */
+List<String> filterUnknownArguments(List<String> args, ArgParser parser) {
+ Set<String> knownOptions = new HashSet<String>();
+ Set<String> knownAbbreviations = new HashSet<String>();
+ parser.options.forEach((String name, Option option) {
+ knownOptions.add(name);
+ String abbreviation = option.abbreviation;
+ if (abbreviation != null) {
+ knownAbbreviations.add(abbreviation);
+ }
+ });
+ String optionName(int prefixLength, String argument) {
+ int equalsOffset = argument.lastIndexOf('=');
+ if (equalsOffset < 0) {
+ return argument.substring(prefixLength);
+ }
+ return argument.substring(prefixLength, equalsOffset);
+ }
+
+ List<String> filtered = <String>[];
+ for (int i = 0; i < args.length; i++) {
+ String argument = args[i];
+ if (argument.startsWith('--') && argument.length > 2) {
+ if (knownOptions.contains(optionName(2, argument))) {
+ filtered.add(argument);
+ }
+ } else if (argument.startsWith('-') && argument.length > 1) {
+ if (knownAbbreviations.contains(optionName(1, argument))) {
+ filtered.add(argument);
+ }
+ } else {
+ filtered.add(argument);
+ }
+ }
+ return filtered;
+}
+
+/**
+ * Use the given [parser] to parse the given command-line [args], and return the
+ * result.
+ */
+ArgResults parse(
+ ResourceProvider provider, ArgParser parser, List<String> args) {
+ args = preprocessArgs(provider, args);
+ if (args.contains('--$ignoreUnrecognizedFlagsFlag')) {
+ args = filterUnknownArguments(args, parser);
+ }
+ return parser.parse(args);
+}
+
+/**
+ * Preprocess the given list of command line [args] by checking whether the real
+ * arguments are in a file (Bazel worker mode).
+ */
+List<String> preprocessArgs(ResourceProvider provider, List<String> args) {
+ if (args.isEmpty) {
+ return args;
+ }
+ String lastArg = args.last;
+ if (lastArg.startsWith('@')) {
+ File argsFile = provider.getFile(lastArg.substring(1));
+ try {
+ List<String> newArgs = args.sublist(0, args.length - 1).toList();
+ newArgs.addAll(argsFile
+ .readAsStringSync()
+ .replaceAll('\r\n', '\n')
+ .replaceAll('\r', '\n')
+ .split('\n')
+ .where((String line) => line.isNotEmpty));
+ return newArgs;
+ } on FileSystemException {
+ // Don't modify args if the file does not exist or cannot be read.
+ }
+ }
+ return args;
+}
diff --git a/pkg/analyzer/lib/src/context/builder.dart b/pkg/analyzer/lib/src/context/builder.dart
index 882094f..d0d9b1e 100644
--- a/pkg/analyzer/lib/src/context/builder.dart
+++ b/pkg/analyzer/lib/src/context/builder.dart
@@ -69,6 +69,11 @@
final ContentCache contentCache;
/**
+ * The options used by the context builder.
+ */
+ final ContextBuilderOptions builderOptions;
+
+ /**
* The resolver provider used to create a package: URI resolver, or `null` if
* the normal (Package Specification DEP) lookup mechanism is to be used.
*/
@@ -83,56 +88,12 @@
ResolverProvider fileResolverProvider;
/**
- * The file path of the .packages file that should be used in place of any
- * file found using the normal (Package Specification DEP) lookup mechanism,
- * or `null` if the normal lookup mechanism should be used.
- */
- String defaultPackageFilePath;
-
- /**
- * The file path of the packages directory that should be used in place of any
- * file found using the normal (Package Specification DEP) lookup mechanism,
- * or `null` if the normal lookup mechanism should be used.
- */
- String defaultPackagesDirectoryPath;
-
- /**
- * The file path of the file containing the summary of the SDK that should be
- * used to "analyze" the SDK. This option should only be specified by
- * command-line tools such as 'dartanalyzer' or 'ddc'.
- */
- String dartSdkSummaryPath;
-
- /**
- * The file path of the analysis options file that should be used in place of
- * any file in the root directory or a parent of the root directory, or `null`
- * if the normal lookup mechanism should be used.
- */
- String defaultAnalysisOptionsFilePath;
-
- /**
- * The default analysis options that should be used unless some or all of them
- * are overridden in the analysis options file, or `null` if the default
- * defaults should be used.
- */
- AnalysisOptions defaultOptions;
-
- /**
- * A table mapping variable names to values for the declared variables, or
- * `null` if no additional variables should be declared.
- */
- Map<String, String> declaredVariables;
-
- /**
- * The manager of pub package summaries.
- */
- PubSummaryManager pubSummaryManager;
-
- /**
* Initialize a newly created builder to be ready to build a context rooted in
* the directory with the given [rootDirectoryPath].
*/
- ContextBuilder(this.resourceProvider, this.sdkManager, this.contentCache);
+ ContextBuilder(this.resourceProvider, this.sdkManager, this.contentCache,
+ {ContextBuilderOptions options})
+ : builderOptions = options ?? new ContextBuilderOptions();
/**
* Return an analysis context that is configured correctly to analyze code in
@@ -158,9 +119,9 @@
* Configure the context to make use of summaries.
*/
void configureSummaries(InternalAnalysisContext context) {
- if (pubSummaryManager != null) {
- List<LinkedPubPackage> linkedBundles =
- pubSummaryManager.getLinkedBundles(context);
+ PubSummaryManager manager = builderOptions.pubSummaryManager;
+ if (manager != null) {
+ List<LinkedPubPackage> linkedBundles = manager.getLinkedBundles(context);
if (linkedBundles.isNotEmpty) {
SummaryDataStore store = new SummaryDataStore([]);
for (LinkedPubPackage package in linkedBundles) {
@@ -211,6 +172,7 @@
* Return an analysis options object containing the default option values.
*/
AnalysisOptions createDefaultOptions() {
+ AnalysisOptions defaultOptions = builderOptions.defaultOptions;
if (defaultOptions == null) {
return new AnalysisOptionsImpl();
}
@@ -218,14 +180,17 @@
}
Packages createPackageMap(String rootDirectoryPath) {
- if (defaultPackageFilePath != null) {
- File configFile = resourceProvider.getFile(defaultPackageFilePath);
+ String filePath = builderOptions.defaultPackageFilePath;
+ if (filePath != null) {
+ File configFile = resourceProvider.getFile(filePath);
List<int> bytes = configFile.readAsBytesSync();
Map<String, Uri> map = parse(bytes, configFile.toUri());
resolveSymbolicLinks(map);
return new MapPackages(map);
- } else if (defaultPackagesDirectoryPath != null) {
- Folder folder = resourceProvider.getFolder(defaultPackagesDirectoryPath);
+ }
+ String directoryPath = builderOptions.defaultPackagesDirectoryPath;
+ if (directoryPath != null) {
+ Folder folder = resourceProvider.getFolder(directoryPath);
return getPackagesFromFolder(folder);
}
return findPackagesFromFile(rootDirectoryPath);
@@ -258,9 +223,10 @@
* given [context].
*/
void declareVariables(InternalAnalysisContext context) {
- if (declaredVariables != null && declaredVariables.isNotEmpty) {
+ Map<String, String> variables = builderOptions.declaredVariables;
+ if (variables != null && variables.isNotEmpty) {
DeclaredVariables contextVariables = context.declaredVariables;
- declaredVariables.forEach((String variableName, String value) {
+ variables.forEach((String variableName, String value) {
contextVariables.define(variableName, value);
});
}
@@ -292,12 +258,13 @@
/**
* Return the SDK that should be used to analyze code. Use the given
- * [packageMap] and [options] to locate the SDK.
+ * [packageMap] and [analysisOptions] to locate the SDK.
*/
DartSdk findSdk(
- Map<String, List<Folder>> packageMap, AnalysisOptions options) {
- if (dartSdkSummaryPath != null) {
- return new SummaryBasedDartSdk(dartSdkSummaryPath, options.strongMode);
+ Map<String, List<Folder>> packageMap, AnalysisOptions analysisOptions) {
+ String summaryPath = builderOptions.dartSdkSummaryPath;
+ if (summaryPath != null) {
+ return new SummaryBasedDartSdk(summaryPath, analysisOptions.strongMode);
} else if (packageMap != null) {
SdkExtensionFinder extFinder = new SdkExtensionFinder(packageMap);
List<String> extFilePaths = extFinder.extensionFilePaths;
@@ -317,12 +284,12 @@
.path);
}
paths.addAll(extFilePaths);
- SdkDescription description = new SdkDescription(paths, options);
+ SdkDescription description = new SdkDescription(paths, analysisOptions);
DartSdk dartSdk = sdkManager.getSdk(description, () {
if (extFilePaths.isNotEmpty) {
embedderSdk.addExtensions(extFinder.urlMappings);
}
- embedderSdk.analysisOptions = options;
+ embedderSdk.analysisOptions = analysisOptions;
embedderSdk.useSummary = sdkManager.canUseSummaries;
return embedderSdk;
});
@@ -334,25 +301,26 @@
String sdkPath = sdkManager.defaultSdkDirectory;
List<String> paths = <String>[sdkPath];
paths.addAll(extFilePaths);
- SdkDescription description = new SdkDescription(paths, options);
+ SdkDescription description = new SdkDescription(paths, analysisOptions);
return sdkManager.getSdk(description, () {
FolderBasedDartSdk sdk = new FolderBasedDartSdk(
resourceProvider, resourceProvider.getFolder(sdkPath));
if (extFilePaths.isNotEmpty) {
sdk.addExtensions(extFinder.urlMappings);
}
- sdk.analysisOptions = options;
+ sdk.analysisOptions = analysisOptions;
sdk.useSummary = sdkManager.canUseSummaries;
return sdk;
});
}
}
String sdkPath = sdkManager.defaultSdkDirectory;
- SdkDescription description = new SdkDescription(<String>[sdkPath], options);
+ SdkDescription description =
+ new SdkDescription(<String>[sdkPath], analysisOptions);
return sdkManager.getSdk(description, () {
FolderBasedDartSdk sdk = new FolderBasedDartSdk(resourceProvider,
- resourceProvider.getFolder(sdkPath), options.strongMode);
- sdk.analysisOptions = options;
+ resourceProvider.getFolder(sdkPath), analysisOptions.strongMode);
+ sdk.analysisOptions = analysisOptions;
sdk.useSummary = sdkManager.canUseSummaries;
return sdk;
});
@@ -386,8 +354,9 @@
* the directory with the given [path].
*/
File getOptionsFile(String path) {
- if (defaultAnalysisOptionsFilePath != null) {
- return resourceProvider.getFile(defaultAnalysisOptionsFilePath);
+ String filePath = builderOptions.defaultAnalysisOptionsFilePath;
+ if (filePath != null) {
+ return resourceProvider.getFile(filePath);
}
Folder root = resourceProvider.getFolder(path);
for (Folder folder = root; folder != null; folder = folder.parent) {
@@ -504,6 +473,62 @@
}
/**
+ * Options used by a [ContextBuilder].
+ */
+class ContextBuilderOptions {
+ /**
+ * The file path of the file containing the summary of the SDK that should be
+ * used to "analyze" the SDK. This option should only be specified by
+ * command-line tools such as 'dartanalyzer' or 'ddc'.
+ */
+ String dartSdkSummaryPath;
+
+ /**
+ * The file path of the analysis options file that should be used in place of
+ * any file in the root directory or a parent of the root directory, or `null`
+ * if the normal lookup mechanism should be used.
+ */
+ String defaultAnalysisOptionsFilePath;
+
+ /**
+ * A table mapping variable names to values for the declared variables, or
+ * `null` if no additional variables should be declared.
+ */
+ Map<String, String> declaredVariables;
+
+ /**
+ * The default analysis options that should be used unless some or all of them
+ * are overridden in the analysis options file, or `null` if the default
+ * defaults should be used.
+ */
+ AnalysisOptions defaultOptions;
+
+ /**
+ * The file path of the .packages file that should be used in place of any
+ * file found using the normal (Package Specification DEP) lookup mechanism,
+ * or `null` if the normal lookup mechanism should be used.
+ */
+ String defaultPackageFilePath;
+
+ /**
+ * The file path of the packages directory that should be used in place of any
+ * file found using the normal (Package Specification DEP) lookup mechanism,
+ * or `null` if the normal lookup mechanism should be used.
+ */
+ String defaultPackagesDirectoryPath;
+
+ /**
+ * The manager of pub package summaries.
+ */
+ PubSummaryManager pubSummaryManager;
+
+ /**
+ * Initialize a newly created set of options
+ */
+ ContextBuilderOptions();
+}
+
+/**
* Given a package map, check in each package's lib directory for the existence
* of an `_embedder.yaml` file. If the file contains a top level YamlMap, it
* will be added to the [embedderYamls] map.
diff --git a/pkg/analyzer/lib/src/dart/analysis/byte_store.dart b/pkg/analyzer/lib/src/dart/analysis/byte_store.dart
new file mode 100644
index 0000000..fb07ac0
--- /dev/null
+++ b/pkg/analyzer/lib/src/dart/analysis/byte_store.dart
@@ -0,0 +1,69 @@
+// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:collection';
+
+/**
+ * Store of bytes associated with string keys.
+ *
+ * Each key must be not longer than 100 characters and consist of only `[a-z]`,
+ * `[0-9]`, `.` and `_` characters. The key cannot be an empty string, the
+ * literal `.`, or contain the sequence `..`.
+ *
+ * Note that associations are not guaranteed to be persistent. The value
+ * associated with a key can change or become `null` at any point in time.
+ *
+ * TODO(scheglov) Research using asynchronous API.
+ */
+abstract class ByteStore {
+ /**
+ * Return the bytes associated with the given [key].
+ * Return `null` if the association does not exist.
+ */
+ List<int> get(String key);
+
+ /**
+ * Associate the given [bytes] with the [key].
+ */
+ void put(String key, List<int> bytes);
+}
+
+/**
+ * A wrapper around [ByteStore] which adds an in-memory LRU cache to it.
+ *
+ * TODO(scheglov) Consider implementing size and/or time eviction policies.
+ */
+class MemoryCachingByteStore implements ByteStore {
+ final ByteStore store;
+ final int maxEntries;
+
+ final _map = <String, List<int>>{};
+ final _keys = new LinkedHashSet<String>();
+
+ MemoryCachingByteStore(this.store, this.maxEntries);
+
+ @override
+ List<int> get(String key) {
+ _keys.remove(key);
+ _keys.add(key);
+ _evict();
+ return _map.putIfAbsent(key, () => store.get(key));
+ }
+
+ @override
+ void put(String key, List<int> bytes) {
+ store.put(key, bytes);
+ _map[key] = bytes;
+ _keys.add(key);
+ _evict();
+ }
+
+ void _evict() {
+ if (_keys.length > maxEntries) {
+ String key = _keys.first;
+ _keys.remove(key);
+ _map.remove(key);
+ }
+ }
+}
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
new file mode 100644
index 0000000..6114222
--- /dev/null
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -0,0 +1,950 @@
+// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:collection';
+import 'dart:convert';
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/error/listener.dart';
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/src/context/context.dart';
+import 'package:analyzer/src/context/source.dart';
+import 'package:analyzer/src/dart/analysis/byte_store.dart';
+import 'package:analyzer/src/dart/error/todo_codes.dart';
+import 'package:analyzer/src/dart/scanner/reader.dart';
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/generated/engine.dart'
+ show AnalysisContext, AnalysisEngine, AnalysisOptions, ChangeSet;
+import 'package:analyzer/src/generated/parser.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:analyzer/src/summary/api_signature.dart';
+import 'package:analyzer/src/summary/flat_buffers.dart' as fb;
+import 'package:analyzer/src/summary/format.dart';
+import 'package:analyzer/src/summary/idl.dart';
+import 'package:analyzer/src/summary/link.dart';
+import 'package:analyzer/src/summary/package_bundle_reader.dart';
+import 'package:analyzer/src/summary/summarize_ast.dart';
+import 'package:analyzer/src/summary/summarize_elements.dart';
+import 'package:analyzer/src/util/fast_uri.dart';
+import 'package:convert/convert.dart';
+import 'package:crypto/crypto.dart';
+
+/**
+ * This class computes [AnalysisResult]s for Dart files.
+ *
+ * Let the set of "explicitly analyzed files" denote the set of paths that have
+ * been passed to [addFile] but not subsequently passed to [removeFile]. Let
+ * the "current analysis results" denote the map from the set of explicitly
+ * analyzed files to the most recent [AnalysisResult] delivered to [results]
+ * for each file. Let the "current file state" represent a map from file path
+ * to the file contents most recently read from that file, or fetched from the
+ * content cache (considering all possible possible file paths, regardless of
+ * whether they're in the set of explicitly analyzed files). Let the
+ * "analysis state" be either "analyzing" or "idle".
+ *
+ * (These are theoretical constructs; they may not necessarily reflect data
+ * structures maintained explicitly by the driver).
+ *
+ * Then we make the following guarantees:
+ *
+ * - Whenever the analysis state is idle, the current analysis results are
+ * consistent with the current file state.
+ *
+ * - A call to [addFile] or [changeFile] causes the analysis state to
+ * transition to "analyzing", and schedules the contents of the given
+ * files to be read into the current file state prior to the next time
+ * the analysis state transitions back to "idle".
+ *
+ * - If at any time the client stops making calls to [addFile], [changeFile],
+ * and [removeFile], the analysis state will eventually transition back to
+ * "idle" after a finite amount of processing.
+ *
+ * As a result of these guarantees, a client may ensure that the analysis
+ * results are "eventually consistent" with the file system by simply calling
+ * [changeFile] any time the contents of a file on the file system have changed.
+ *
+ *
+ * TODO(scheglov) Clean up the list of implicitly analyzed files.
+ */
+class AnalysisDriver {
+ final PerformanceLog _logger;
+
+ /**
+ * The resource provider for working with files.
+ */
+ final ResourceProvider _resourceProvider;
+
+ /**
+ * The byte storage to get and put serialized data.
+ *
+ * It can be shared with other [AnalysisDriver]s.
+ */
+ final ByteStore _byteStore;
+
+ /**
+ * This [ContentCache] is consulted for a file content before reading
+ * the content from the file.
+ */
+ final ContentCache _contentCache;
+
+ /**
+ * The [SourceFactory] is used to resolve URIs to paths and restore URIs
+ * from file paths.
+ */
+ final SourceFactory _sourceFactory;
+
+ /**
+ * The analysis options to analyze with.
+ */
+ final AnalysisOptions _analysisOptions;
+
+ /**
+ * The combined unlinked and linked package for the SDK, extracted from
+ * the given [_sourceFactory].
+ */
+ PackageBundle _sdkBundle;
+
+ /**
+ * The mapping from the files for which analysis was requested using
+ * [getResult] to the [Completer]s to report the result.
+ */
+ final _requestedFiles = <String, Completer<AnalysisResult>>{};
+
+ /**
+ * The set of explicitly analyzed files.
+ */
+ final _explicitFiles = new LinkedHashSet<String>();
+
+ /**
+ * The set of files that are currently scheduled for analysis.
+ */
+ final _filesToAnalyze = new LinkedHashSet<String>();
+
+ /**
+ * The mapping of [Uri]s to the mapping of textual URIs to the [Source]
+ * that correspond in the current [_sourceFactory].
+ */
+ final _uriResolutionCache = <Uri, Map<String, Source>>{};
+
+ /**
+ * The current file state.
+ *
+ * It maps file paths to the MD5 hash of the file content.
+ */
+ final _fileContentHashMap = <String, String>{};
+
+ /**
+ * Mapping from library URIs to the linked hash of the library.
+ */
+ final _linkedHashMap = <Uri, String>{};
+
+ /**
+ * TODO(scheglov) document and improve
+ */
+ final _hasWorkStreamController = new StreamController<String>();
+
+ AnalysisDriver(this._logger, this._resourceProvider, this._byteStore,
+ this._contentCache, this._sourceFactory, this._analysisOptions) {
+ _sdkBundle = _sourceFactory.dartSdk.getLinkedBundle();
+ }
+
+ /**
+ * Set the list of files that the driver should try to analyze sooner.
+ *
+ * Every path in the list must be absolute and normalized.
+ *
+ * The driver will produce the results through the [results] stream. The
+ * exact order in which results are produced is not defined, neither
+ * between priority files, nor between priority and non-priority files.
+ */
+ void set priorityFiles(List<String> priorityPaths) {
+ // TODO(scheglov) implement
+ }
+
+ /**
+ * Return the [Stream] that produces [AnalysisResult]s for added files.
+ *
+ * Analysis starts when the client starts listening to the stream, and stops
+ * when the client cancels the subscription.
+ *
+ * When the client starts listening, the analysis state transitions to
+ * "analyzing" and an analysis result is produced for every added file prior
+ * to the next time the analysis state transitions to "idle".
+ *
+ * Invocation of [addFile] or [changeFile] might result in producing more
+ * analysis results that reflect the new current file state.
+ *
+ * More than one result might be produced for the same file, even if the
+ * client does not change the state of the files.
+ *
+ * Results might be produced even for files that have never been added
+ * using [addFile], for example when [getResult] was called for a file.
+ */
+ Stream<AnalysisResult> get results async* {
+ try {
+ while (true) {
+ // TODO(scheglov) implement state transitioning
+ await for (String why in _hasWorkStreamController.stream) {
+ // Analyze the first file in the general queue.
+ if (_filesToAnalyze.isNotEmpty) {
+ _logger.runTimed('Analyzed ${_filesToAnalyze.length} files', () {
+ while (_filesToAnalyze.isNotEmpty) {
+ String path = _filesToAnalyze.first;
+ _filesToAnalyze.remove(path);
+ _File file = _fileForPath(path);
+ _computeAndPrintErrors(file);
+ // TODO(scheglov) yield the result
+ }
+ });
+ }
+ }
+ // TODO(scheglov) implement
+ }
+ } finally {
+ print('The stream was cancelled.');
+ }
+ }
+
+ /**
+ * Add the file with the given [path] to the set of files to analyze.
+ *
+ * The [path] must be absolute and normalized.
+ *
+ * The results of analysis are eventually produced by the [results] stream.
+ */
+ void addFile(String path) {
+ _explicitFiles.add(path);
+ _filesToAnalyze.add(path);
+ _hasWorkStreamController.add('do it!');
+ }
+
+ /**
+ * The file with the given [path] might have changed - updated, added or
+ * removed. Or not, we don't know. Or it might have, but then changed back.
+ *
+ * The [path] must be absolute and normalized.
+ *
+ * The [path] can be any file - explicitly or implicitly analyzed, or neither.
+ *
+ * Causes the analysis state to transition to "analyzing" (if it is not in
+ * that state already). Schedules the file contents for [path] to be read
+ * into the current file state prior to the next time the analysis state
+ * transitions to "idle".
+ *
+ * Invocation of this method will not prevent a [Future] returned from
+ * [getResult] from completing with a result, but the result is not
+ * guaranteed to be consistent with the new current file state after this
+ * [changeFile] invocation.
+ */
+ void changeFile(String path) {
+ // TODO(scheglov) Don't clear, schedule API signature validation.
+ _fileContentHashMap.clear();
+ _linkedHashMap.clear();
+ _filesToAnalyze.add(path);
+ _filesToAnalyze.addAll(_explicitFiles);
+ // TODO(scheglov) name?!
+ _hasWorkStreamController.add('do it!');
+ }
+
+ /**
+ * Return the [Future] that completes with a [AnalysisResult] for the file
+ * with the given [path].
+ *
+ * The [path] must be absolute and normalized.
+ *
+ * The [path] can be any file - explicitly or implicitly analyzed, or neither.
+ *
+ * Causes the analysis state to transition to "analyzing" (if it is not in
+ * that state already), the driver will read the file and produce the analysis
+ * result for it, which is consistent with the current file state (including
+ * the new state of the file), prior to the next time the analysis state
+ * transitions to "idle".
+ */
+ Future<AnalysisResult> getResult(String path) {
+ var completer = new Completer<AnalysisResult>();
+ _requestedFiles[path] = completer;
+ return completer.future;
+ }
+
+ /**
+ * Remove the file with the given [path] from the list of files to analyze.
+ *
+ * The [path] must be absolute and normalized.
+ *
+ * The results of analysis of the file might still be produced by the
+ * [results] stream. The driver will try to stop producing these results,
+ * but does not guarantee this.
+ */
+ void removeFile(String path) {
+ _explicitFiles.remove(path);
+ _filesToAnalyze.remove(path);
+ }
+
+ /**
+ * TODO(scheglov) replace with actual [AnalysisResult] computing.
+ */
+ List<String> _computeAndPrintErrors(_File file) {
+ // TODO(scheglov) Computing resolved unit fails for these units.
+ // pkg/analyzer/lib/plugin/embedded_resolver_provider.dart
+ // pkg/analyzer/lib/plugin/embedded_resolver_provider.dart
+ if (file.path.endsWith(
+ 'pkg/analyzer/lib/plugin/embedded_resolver_provider.dart') ||
+ file.path.endsWith('pkg/analyzer/lib/source/embedder.dart') ||
+ file.path.endsWith('pkg/analyzer/lib/src/generated/ast.dart') ||
+ file.path.endsWith('pkg/analyzer/lib/src/generated/element.dart') ||
+ file.path
+ .endsWith('pkg/analyzer/lib/src/generated/element_handle.dart') ||
+ file.path.endsWith('pkg/analyzer/lib/src/generated/error.dart') ||
+ file.path.endsWith('pkg/analyzer/lib/src/generated/scanner.dart') ||
+ file.path.endsWith('pkg/analyzer/lib/src/generated/sdk_io.dart') ||
+ file.path.endsWith('pkg/analyzer/lib/src/generated/visitors.dart') ||
+ file.path.endsWith('pkg/analyzer/test/generated/constant_test.dart') ||
+ file.path.endsWith('pkg/analyzer/test/source/embedder_test.dart')) {
+ return [];
+ }
+
+ List<String> errorStrings = _logger.run('Compute errors $file', () {
+ LibraryContext libraryContext = _createLibraryContext(file);
+
+ String errorsKey;
+ {
+ ApiSignature signature = new ApiSignature();
+ signature.addString(libraryContext.node.linkedHash);
+ signature.addString(file.contentHash);
+ errorsKey = '${signature.toHex()}.errors';
+ }
+
+ {
+ List<int> bytes = _byteStore.get(errorsKey);
+ if (bytes != null) {
+ fb.BufferContext bp = new fb.BufferContext.fromBytes(bytes);
+ int table = bp.derefObject(0);
+ return const fb.ListReader<String>(const fb.StringReader())
+ .vTableGet(bp, table, 0);
+ }
+ }
+
+ AnalysisContext analysisContext = _createAnalysisContext(libraryContext);
+ analysisContext.setContents(file.source, file.content);
+ try {
+ // Compute resolved unit.
+// _logger.runTimed('Computed resolved unit', () {
+// analysisContext.resolveCompilationUnit2(
+// libraryContext.file.source, libraryContext.file.source);
+// });
+ // Compute errors.
+ List<AnalysisError> errors;
+ try {
+ errors = _logger.runTimed('Computed errors', () {
+ return analysisContext.computeErrors(file.source);
+ });
+ } catch (e, st) {
+ // TODO(scheglov) why does it fail?
+ // Caused by Bad state: Unmatched TypeParameterElementImpl T
+ errors = [];
+ }
+ List<String> errorStrings = errors
+ .where((error) => error.errorCode is! TodoCode)
+ .map((error) => error.toString())
+ .toList();
+ {
+ fb.Builder fbBuilder = new fb.Builder();
+ var exportedOffset = fbBuilder.writeList(errorStrings
+ .map((errorStr) => fbBuilder.writeString(errorStr))
+ .toList());
+ fbBuilder.startTable();
+ fbBuilder.addOffset(0, exportedOffset);
+ var offset = fbBuilder.endTable();
+ List<int> bytes = fbBuilder.finish(offset, 'CErr');
+ _byteStore.put(errorsKey, bytes);
+ }
+
+ return errorStrings;
+ } finally {
+ analysisContext.dispose();
+ }
+ });
+
+ if (errorStrings.isNotEmpty) {
+ errorStrings.forEach((errorString) => print('\t$errorString'));
+ } else {
+ print('\tNO ERRORS');
+ }
+ return errorStrings;
+ }
+
+ AnalysisContext _createAnalysisContext(LibraryContext libraryContext) {
+ AnalysisContextImpl analysisContext =
+ AnalysisEngine.instance.createAnalysisContext();
+
+ analysisContext.sourceFactory =
+ new SourceFactory((_sourceFactory as SourceFactoryImpl).resolvers);
+ analysisContext.resultProvider =
+ new InputPackagesResultProvider(analysisContext, libraryContext.store);
+ analysisContext
+ .applyChanges(new ChangeSet()..addedSource(libraryContext.file.source));
+ return analysisContext;
+ }
+
+ /**
+ * Return the content in which the library represented by the given
+ * [libraryFile] should be analyzed it.
+ *
+ * TODO(scheglov) We often don't need [SummaryDataStore], only linked hash.
+ */
+ LibraryContext _createLibraryContext(_File libraryFile) {
+ Map<String, _LibraryNode> nodes = <String, _LibraryNode>{};
+
+ return _logger.run('Create library context', () {
+ SummaryDataStore store = new SummaryDataStore(const <String>[]);
+ store.addBundle(null, _sdkBundle);
+
+ void createLibraryNodes(_File libraryFile) {
+ Uri libraryUri = libraryFile.uri;
+ if (libraryUri.scheme == 'dart') {
+ return;
+ }
+ String uriStr = libraryUri.toString();
+ if (!nodes.containsKey(uriStr)) {
+ _LibraryNode node = new _LibraryNode(this, nodes, libraryUri);
+ nodes[uriStr] = node;
+ ReferencedUris referenced = _getReferencedUris(libraryFile);
+
+ // Append unlinked bundles.
+ for (String uri in referenced.parted) {
+ _File file = libraryFile.resolveUri(uri);
+ PackageBundle unlinked = _getUnlinked(file);
+ node.unlinkedBundles.add(unlinked);
+ store.addBundle(null, unlinked);
+ }
+
+ // Create nodes for referenced libraries.
+ for (String uri in referenced.imported) {
+ _File file = libraryFile.resolveUri(uri);
+ createLibraryNodes(file);
+ }
+ for (String uri in referenced.exported) {
+ _File file = libraryFile.resolveUri(uri);
+ createLibraryNodes(file);
+ }
+ }
+ }
+
+ _logger.runTimed2(() {
+ createLibraryNodes(libraryFile);
+ }, () => 'Computed ${nodes.length} nodes');
+ _LibraryNode libraryNode = nodes[libraryFile.uri.toString()];
+
+ Set<String> libraryUrisToLink = new Set<String>();
+ int numberOfNodesWithLinked = 0;
+ _logger.runTimed2(() {
+ for (_LibraryNode node in nodes.values) {
+ String key = '${node.linkedHash}.linked';
+ List<int> bytes = _byteStore.get(key);
+ if (bytes != null) {
+ PackageBundle linked = new PackageBundle.fromBuffer(bytes);
+ store.addBundle(null, linked);
+ numberOfNodesWithLinked++;
+ } else {
+ libraryUrisToLink.add(node.uri.toString());
+ }
+ }
+ }, () => 'Loaded $numberOfNodesWithLinked linked bundles');
+
+ Map<String, LinkedLibraryBuilder> linkedLibraries = {};
+ _logger.runTimed2(() {
+ linkedLibraries = link(libraryUrisToLink, (String uri) {
+ LinkedLibrary linkedLibrary = store.linkedMap[uri];
+ if (linkedLibrary == null) {
+ throw new StateError('No linked library for: $uri');
+ }
+ return linkedLibrary;
+ }, (String uri) {
+ UnlinkedUnit unlinkedUnit = store.unlinkedMap[uri];
+ if (unlinkedUnit == null) {
+ throw new StateError('No unlinked unit for: $uri');
+ }
+ return unlinkedUnit;
+ }, (_) => null, _analysisOptions.strongMode);
+ }, () => 'Linked ${linkedLibraries.length} bundles');
+
+ linkedLibraries.forEach((uri, linkedBuilder) {
+ _LibraryNode node = nodes[uri];
+ String key = '${node.linkedHash}.linked';
+ List<int> bytes;
+ {
+ PackageBundleAssembler assembler = new PackageBundleAssembler();
+ assembler.addLinkedLibrary(uri, linkedBuilder);
+ bytes = assembler.assemble().toBuffer();
+ }
+ PackageBundle linked = new PackageBundle.fromBuffer(bytes);
+ store.addBundle(null, linked);
+ _byteStore.put(key, bytes);
+ });
+
+ return new LibraryContext(libraryFile, libraryNode, store);
+ });
+ }
+
+ /**
+ * Return the [_File] for the given [path] in [_sourceFactory].
+ */
+ _File _fileForPath(String path) {
+ Source fileSource = _resourceProvider.getFile(path).createSource();
+ Uri uri = _sourceFactory.restoreUri(fileSource);
+ Source source = _resourceProvider.getFile(path).createSource(uri);
+ return new _File(this, source);
+ }
+
+ /**
+ * TODO(scheglov) It would be nice to get URIs of "parts" from unlinked.
+ */
+ ReferencedUris _getReferencedUris(_File file) {
+ // Try to get from the store.
+ {
+ String key = '${file.contentHash}.uris';
+ List<int> bytes = _byteStore.get(key);
+ if (bytes != null) {
+ fb.BufferContext bp = new fb.BufferContext.fromBytes(bytes);
+ int table = bp.derefObject(0);
+ const fb.ListReader<String> stringListReader =
+ const fb.ListReader<String>(const fb.StringReader());
+ bool isLibrary = const fb.BoolReader().vTableGet(bp, table, 0);
+ List<String> imported = stringListReader.vTableGet(bp, table, 1);
+ List<String> exported = stringListReader.vTableGet(bp, table, 2);
+ List<String> parted = stringListReader.vTableGet(bp, table, 3);
+ ReferencedUris referencedUris = new ReferencedUris();
+ referencedUris.isLibrary = isLibrary;
+ referencedUris.imported.addAll(imported);
+ referencedUris.exported.addAll(exported);
+ referencedUris.parted.addAll(parted);
+ return referencedUris;
+ }
+ }
+
+ // Compute URIs.
+ ReferencedUris referencedUris = new ReferencedUris();
+ referencedUris.parted.add(file.uri.toString());
+ for (Directive directive in file.unit.directives) {
+ if (directive is PartOfDirective) {
+ referencedUris.isLibrary = false;
+ } else if (directive is UriBasedDirective) {
+ String uri = directive.uri.stringValue;
+ if (directive is ImportDirective) {
+ referencedUris.imported.add(uri);
+ } else if (directive is ExportDirective) {
+ referencedUris.exported.add(uri);
+ } else if (directive is PartDirective) {
+ referencedUris.parted.add(uri);
+ }
+ }
+ }
+
+ // Serialize into bytes.
+ List<int> bytes;
+ {
+ fb.Builder fbBuilder = new fb.Builder();
+ var importedOffset = fbBuilder.writeList(referencedUris.imported
+ .map((uri) => fbBuilder.writeString(uri))
+ .toList());
+ var exportedOffset = fbBuilder.writeList(referencedUris.exported
+ .map((uri) => fbBuilder.writeString(uri))
+ .toList());
+ var partedOffset = fbBuilder.writeList(referencedUris.parted
+ .map((uri) => fbBuilder.writeString(uri))
+ .toList());
+ fbBuilder.startTable();
+ fbBuilder.addBool(0, referencedUris.isLibrary);
+ fbBuilder.addOffset(1, importedOffset);
+ fbBuilder.addOffset(2, exportedOffset);
+ fbBuilder.addOffset(3, partedOffset);
+ var offset = fbBuilder.endTable();
+ bytes = fbBuilder.finish(offset, 'SoRU');
+ }
+
+ // We read the content and recomputed the hash.
+ // So, we need to update the key.
+ String key = '${file.contentHash}.uris';
+ _byteStore.put(key, bytes);
+
+ return referencedUris;
+ }
+
+ /**
+ * Return the unlinked bundle of [file] for the current file state.
+ *
+ * That is, if there is an existing bundle for the current content hash
+ * of the [file] in the [_byteStore], then it is returned. Otherwise, the
+ * [file] content is read, the content hash is computed and the current file
+ * state is updated accordingly. That the content is parsed into the
+ * [CompilationUnit] and serialized into a new unlinked bundle. The bundle
+ * is then put into the [_byteStore] and returned.
+ */
+ PackageBundle _getUnlinked(_File file) {
+ // Try to get bytes for file's unlinked bundle.
+ List<int> bytes;
+ {
+ String key = '${file.contentHash}.unlinked';
+ bytes = _byteStore.get(key);
+ }
+ // If no cached unlinked bundle, compute it.
+ if (bytes == null) {
+ _logger.runTimed('Create unlinked for $file', () {
+ // We read the content and recomputed the hash.
+ // So, we need to update the key.
+ String key = '${file.contentHash}.unlinked';
+ UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(file.unit);
+ PackageBundleAssembler assembler = new PackageBundleAssembler();
+ assembler.addUnlinkedUnitWithHash(
+ file.uri.toString(), unlinkedUnit, key);
+ bytes = assembler.assemble().toBuffer();
+ _byteStore.put(key, bytes);
+ });
+ }
+ return new PackageBundle.fromBuffer(bytes);
+ }
+}
+
+/**
+ * The result of analyzing of a single file.
+ *
+ * These results are self-consistent, i.e. [content], [contentHash], the
+ * resolved [unit] correspond to each other. All referenced elements, even
+ * external ones, are also self-consistent. But none of the results is
+ * guaranteed to be consistent with the state of the files.
+ *
+ * Every result is independent, and is not guaranteed to be consistent with
+ * any previously returned result, even inside of the same library.
+ */
+class AnalysisResult {
+ /**
+ * The path of the analysed file, absolute and normalized.
+ */
+ final String path;
+
+ /**
+ * The URI of the file that corresponded to the [path] in the used
+ * [SourceFactory] at some point. Is it not guaranteed to be still consistent
+ * to the [path], and provided as FYI.
+ */
+ final Uri uri;
+
+ /**
+ * The content of the file that was scanned, parsed and resolved.
+ */
+ final String content;
+
+ /**
+ * The MD5 hash of the [content].
+ */
+ final String contentHash;
+
+ /**
+ * The fully resolved compilation unit for the [content].
+ */
+ final CompilationUnit unit;
+
+ /**
+ * The full list of computed analysis errors, both syntactic and semantic.
+ */
+ final List<AnalysisError> errors;
+
+ AnalysisResult(this.path, this.uri, this.content, this.contentHash, this.unit,
+ this.errors);
+}
+
+class LibraryContext {
+ final _File file;
+ final _LibraryNode node;
+ final SummaryDataStore store;
+ LibraryContext(this.file, this.node, this.store);
+}
+
+class PerformanceLog {
+ final StringSink sink;
+ int _level = 0;
+
+ PerformanceLog(this.sink);
+
+ /*=T*/ run/*<T>*/(String msg, /*=T*/ f()) {
+ Stopwatch timer = new Stopwatch()..start();
+ try {
+ writeln('+++ $msg.');
+ _level++;
+ return f();
+ } finally {
+ _level--;
+ int ms = timer.elapsedMilliseconds;
+ writeln('--- $msg in $ms ms.');
+ }
+ }
+
+ /*=T*/ runTimed/*<T>*/(String msg, /*=T*/ f()) {
+ _level++;
+ Stopwatch timer = new Stopwatch()..start();
+ try {
+ return f();
+ } finally {
+ _level--;
+ int ms = timer.elapsedMilliseconds;
+ writeln('$msg in $ms ms.');
+ }
+ }
+
+ runTimed2(f(), String getMsg()) {
+ _level++;
+ Stopwatch timer = new Stopwatch()..start();
+ try {
+ return f();
+ } finally {
+ _level--;
+ int ms = timer.elapsedMilliseconds;
+ String msg = getMsg();
+ writeln('$msg in $ms ms.');
+ }
+ }
+
+ void writeln(String msg) {
+ String indent = '\t' * _level;
+ sink.writeln('$indent$msg');
+ }
+}
+
+class ReferencedUris {
+ bool isLibrary = true;
+ final List<String> imported = <String>[];
+ final List<String> exported = <String>[];
+ final List<String> parted = <String>[];
+}
+
+/**
+ * Information about a file being analyzed, explicitly or implicitly.
+ *
+ * It keeps a consistent view on its [content], [contentHash] and [unit].
+ */
+class _File {
+ /**
+ * The driver instance that is used to access [SourceFactory] and caches.
+ */
+ final AnalysisDriver driver;
+
+ /**
+ * The [Source] this [_File] instance represent.
+ */
+ final Source source;
+
+ String _content;
+ String _contentHash;
+ CompilationUnit _unit;
+
+ _File(this.driver, this.source);
+
+ /**
+ * Return the current content of the file.
+ *
+ * If the [_content] field if it is still `null`, get the content from the
+ * content cache or from the [source]. If the content cannot be accessed
+ * because of an exception, it considers to be an empty string.
+ *
+ * When a new content is read, the new [_contentHash] is computed and the
+ * current file state is updated.
+ */
+ String get content {
+ if (_content == null) {
+ _readContentAndComputeHash();
+ }
+ return _content;
+ }
+
+ /**
+ * Ensure that the [contentHash] is filled.
+ *
+ * If the hash is already in the current file state, return the current
+ * value. Otherwise, read the [content], compute the hash, put it into
+ * the current file state, and update the [contentHash] field.
+ *
+ * The client cannot remember values of this property, because its value
+ * might change when [content] is read and the hash is recomputed.
+ */
+ String get contentHash {
+ _contentHash ??= driver._fileContentHashMap[path];
+ if (_contentHash == null) {
+ _readContentAndComputeHash();
+ }
+ return _contentHash;
+ }
+
+ String get path => source.fullName;
+
+ /**
+ * Return the [CompilationUnit] of the file.
+ *
+ * Current this unit is resolved, it is used to compute unlinked summaries
+ * and and URIs. We use a separate analysis context to perform resolution
+ * and computing errors. But this might change in the future.
+ */
+ CompilationUnit get unit {
+ AnalysisErrorListener errorListener = AnalysisErrorListener.NULL_LISTENER;
+
+ CharSequenceReader reader = new CharSequenceReader(content);
+ Scanner scanner = new Scanner(source, reader, errorListener);
+ scanner.scanGenericMethodComments = driver._analysisOptions.strongMode;
+ Token token = scanner.tokenize();
+ LineInfo lineInfo = new LineInfo(scanner.lineStarts);
+
+ Parser parser = new Parser(source, errorListener);
+ parser.parseGenericMethodComments = driver._analysisOptions.strongMode;
+ _unit = parser.parseCompilationUnit(token);
+ _unit.lineInfo = lineInfo;
+
+ return _unit;
+ }
+
+ Uri get uri => source.uri;
+
+ /**
+ * Return the [_File] for the [uri] referenced in this file.
+ */
+ _File resolveUri(String uri) {
+ Source uriSource = driver._uriResolutionCache
+ .putIfAbsent(this.uri, () => <String, Source>{})
+ .putIfAbsent(uri, () => driver._sourceFactory.resolveUri(source, uri));
+ return new _File(driver, uriSource);
+ }
+
+ @override
+ String toString() => uri.toString();
+
+ /**
+ * Fill the [_content] and [_contentHash] fields.
+ *
+ * If the [_content] field if it is still `null`, get the content from the
+ * content cache or from the [source]. If the content cannot be accessed
+ * because of an exception, it considers to be an empty string.
+ *
+ * When a new content is read, the new [_contentHash] should be computed and
+ * the current file state should be updated.
+ */
+ void _readContentAndComputeHash() {
+ try {
+ _content = driver._contentCache.getContents(source);
+ _content ??= source.contents.data;
+ } catch (_) {
+ _content = '';
+ }
+ // Compute the content hash.
+ List<int> textBytes = UTF8.encode(_content);
+ List<int> hashBytes = md5.convert(textBytes).bytes;
+ _contentHash = hex.encode(hashBytes);
+ // Update the current file state.
+ driver._fileContentHashMap[path] = _contentHash;
+ }
+}
+
+class _LibraryNode {
+ final AnalysisDriver driver;
+ final Map<String, _LibraryNode> nodes;
+ final Uri uri;
+ final List<PackageBundle> unlinkedBundles = <PackageBundle>[];
+
+ Set<_LibraryNode> transitiveDependencies;
+ List<_LibraryNode> _dependencies;
+ String _linkedHash;
+
+ _LibraryNode(this.driver, this.nodes, this.uri);
+
+ /**
+ * Retrieve the dependencies of this node.
+ */
+ List<_LibraryNode> get dependencies {
+ if (_dependencies == null) {
+ Set<_LibraryNode> dependencies = new Set<_LibraryNode>();
+
+ void appendDependency(String uriStr) {
+ Uri uri = FastUri.parse(uriStr);
+ if (uri.scheme == 'dart') {
+ // Dependency on the SDK is implicit and always added.
+ // The SDK linked bundle is precomputed before linking packages.
+ } else {
+ if (!uri.isAbsolute) {
+ uri = resolveRelativeUri(this.uri, uri);
+ uriStr = uri.toString();
+ }
+ _LibraryNode node = nodes[uriStr];
+ if (node == null) {
+ throw new StateError('No node for: $uriStr');
+ }
+ dependencies.add(node);
+ }
+ }
+
+ for (PackageBundle unlinkedBundle in unlinkedBundles) {
+ for (UnlinkedUnit unit in unlinkedBundle.unlinkedUnits) {
+ for (UnlinkedImport import in unit.imports) {
+ if (!import.isImplicit) {
+ appendDependency(import.uri);
+ }
+ }
+ for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
+ appendDependency(export.uri);
+ }
+ }
+ }
+
+ _dependencies = dependencies.toList();
+ }
+ return _dependencies;
+ }
+
+ @override
+ int get hashCode => uri.hashCode;
+
+ String get linkedHash {
+ _linkedHash ??= driver._linkedHashMap.putIfAbsent(uri, () {
+ computeTransitiveDependencies();
+
+ // Add all unlinked API signatures.
+ List<String> signatures = <String>[];
+ signatures.add(driver._sdkBundle.apiSignature);
+ transitiveDependencies
+ .map((node) => node.unlinkedBundles)
+ .expand((bundles) => bundles)
+ .map((bundle) => bundle.apiSignature)
+ .forEach(signatures.add);
+ signatures.sort();
+
+ // Combine into a single hash.
+ ApiSignature signature = new ApiSignature();
+ signature.addString(uri.toString());
+ signatures.forEach(signature.addString);
+ return signature.toHex();
+ });
+ return _linkedHash;
+ }
+
+ bool operator ==(other) {
+ return other is _LibraryNode && other.uri == uri;
+ }
+
+ void computeTransitiveDependencies() {
+ if (transitiveDependencies == null) {
+ transitiveDependencies = new Set<_LibraryNode>();
+
+ void appendDependencies(_LibraryNode node) {
+ if (transitiveDependencies.add(node)) {
+ node.dependencies.forEach(appendDependencies);
+ }
+ }
+
+ appendDependencies(this);
+ }
+ }
+
+ @override
+ String toString() => uri.toString();
+}
diff --git a/pkg/analyzer/lib/src/dart/analysis/file_byte_store.dart b/pkg/analyzer/lib/src/dart/analysis/file_byte_store.dart
new file mode 100644
index 0000000..49e668f
--- /dev/null
+++ b/pkg/analyzer/lib/src/dart/analysis/file_byte_store.dart
@@ -0,0 +1,35 @@
+// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/src/dart/analysis/byte_store.dart';
+
+/**
+ * [ByteStore] that stores values as [File]s.
+ *
+ * TODO(scheglov) Add some eviction policies.
+ */
+class FileByteStore implements ByteStore {
+ final Folder folder;
+
+ FileByteStore(this.folder);
+
+ @override
+ List<int> get(String key) {
+ try {
+ File file = folder.getChildAssumingFile(key);
+ return file.readAsBytesSync();
+ } catch (_) {
+ return null;
+ }
+ }
+
+ @override
+ void put(String key, List<int> bytes) {
+ try {
+ File file = folder.getChildAssumingFile(key);
+ file.writeAsBytesSync(bytes);
+ } catch (_) {}
+ }
+}
diff --git a/pkg/analyzer/lib/src/dart/ast/ast.dart b/pkg/analyzer/lib/src/dart/ast/ast.dart
index b260fa8..930cebf 100644
--- a/pkg/analyzer/lib/src/dart/ast/ast.dart
+++ b/pkg/analyzer/lib/src/dart/ast/ast.dart
@@ -17,7 +17,6 @@
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/type.dart';
import 'package:analyzer/src/generated/engine.dart' show AnalysisEngine;
-import 'package:analyzer/src/generated/java_core.dart';
import 'package:analyzer/src/generated/java_engine.dart';
import 'package:analyzer/src/generated/parser.dart';
import 'package:analyzer/src/generated/source.dart' show LineInfo, Source;
@@ -941,9 +940,9 @@
@override
String toSource() {
- PrintStringWriter writer = new PrintStringWriter();
- accept(new ToSourceVisitor(writer));
- return writer.toString();
+ StringBuffer buffer = new StringBuffer();
+ accept(new ToSourceVisitor2(buffer));
+ return buffer.toString();
}
@override
diff --git a/pkg/analyzer/lib/src/dart/ast/utilities.dart b/pkg/analyzer/lib/src/dart/ast/utilities.dart
index a1e5448..654772c 100644
--- a/pkg/analyzer/lib/src/dart/ast/utilities.dart
+++ b/pkg/analyzer/lib/src/dart/ast/utilities.dart
@@ -6769,7 +6769,10 @@
/**
* A visitor used to write a source representation of a visited AST node (and
* all of it's children) to a writer.
+ *
+ * This class has been deprecated. Use the class ToSourceVisitor2 instead.
*/
+@deprecated
class ToSourceVisitor implements AstVisitor<Object> {
/**
* The writer to which the source is to be written.
diff --git a/pkg/analyzer/lib/src/dart/element/builder.dart b/pkg/analyzer/lib/src/dart/element/builder.dart
index b45f44e..b421e75 100644
--- a/pkg/analyzer/lib/src/dart/element/builder.dart
+++ b/pkg/analyzer/lib/src/dart/element/builder.dart
@@ -1078,8 +1078,11 @@
CompilationUnitElementImpl compilationUnitElement)
: super(initialHolder, compilationUnitElement);
- @override
- Object visitCatchClause(CatchClause node) {
+ /**
+ * Builds the variable elements associated with [node] and stores them in
+ * the element holder.
+ */
+ void buildCatchVariableElements(CatchClause node) {
SimpleIdentifier exceptionParameter = node.exceptionParameter;
if (exceptionParameter != null) {
// exception
@@ -1102,6 +1105,26 @@
stackTraceParameter.staticElement = stackTrace;
}
}
+ }
+
+ /**
+ * Builds the label elements associated with [labels] and stores them in the
+ * element holder.
+ */
+ void buildLabelElements(
+ NodeList<Label> labels, bool onSwitchStatement, bool onSwitchMember) {
+ for (Label label in labels) {
+ SimpleIdentifier labelName = label.label;
+ LabelElementImpl element = new LabelElementImpl.forNode(
+ labelName, onSwitchStatement, onSwitchMember);
+ labelName.staticElement = element;
+ _currentHolder.addLabel(element);
+ }
+ }
+
+ @override
+ Object visitCatchClause(CatchClause node) {
+ buildCatchVariableElements(node);
return super.visitCatchClause(node);
}
@@ -1226,37 +1249,19 @@
@override
Object visitLabeledStatement(LabeledStatement node) {
bool onSwitchStatement = node.statement is SwitchStatement;
- for (Label label in node.labels) {
- SimpleIdentifier labelName = label.label;
- LabelElementImpl element =
- new LabelElementImpl.forNode(labelName, onSwitchStatement, false);
- _currentHolder.addLabel(element);
- labelName.staticElement = element;
- }
+ buildLabelElements(node.labels, onSwitchStatement, false);
return super.visitLabeledStatement(node);
}
@override
Object visitSwitchCase(SwitchCase node) {
- for (Label label in node.labels) {
- SimpleIdentifier labelName = label.label;
- LabelElementImpl element =
- new LabelElementImpl.forNode(labelName, false, true);
- _currentHolder.addLabel(element);
- labelName.staticElement = element;
- }
+ buildLabelElements(node.labels, false, true);
return super.visitSwitchCase(node);
}
@override
Object visitSwitchDefault(SwitchDefault node) {
- for (Label label in node.labels) {
- SimpleIdentifier labelName = label.label;
- LabelElementImpl element =
- new LabelElementImpl.forNode(labelName, false, true);
- _currentHolder.addLabel(element);
- labelName.staticElement = element;
- }
+ buildLabelElements(node.labels, false, true);
return super.visitSwitchDefault(node);
}
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 6c18785..ddfc3b4 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -870,10 +870,11 @@
@override
int get nameOffset {
- if (_unlinkedClass != null) {
+ int offset = super.nameOffset;
+ if (offset == 0 && _unlinkedClass != null) {
return _unlinkedClass.nameOffset;
}
- return super.nameOffset;
+ return offset;
}
@override
@@ -1236,6 +1237,7 @@
field.synthetic = true;
field.final2 = e.kind == UnlinkedExecutableKind.getter;
field.type = fieldType;
+ field.static = e.isStatic;
} else {
field.final2 = false;
}
@@ -1851,10 +1853,11 @@
@override
int get nameOffset {
- if (_unlinkedEnumValue != null) {
+ int offset = super.nameOffset;
+ if (offset == -1 && _unlinkedEnumValue != null) {
return _unlinkedEnumValue.nameOffset;
}
- return super.nameOffset;
+ return offset;
}
@override
@@ -3477,10 +3480,11 @@
@override
int get nameOffset {
- if (_unlinkedEnum != null) {
+ int offset = super.nameOffset;
+ if (offset == 0 && _unlinkedEnum != null && _unlinkedEnum.nameOffset != 0) {
return _unlinkedEnum.nameOffset;
}
- return super.nameOffset;
+ return offset;
}
@override
@@ -3826,10 +3830,11 @@
@override
int get nameOffset {
- if (serializedExecutable != null) {
+ int offset = super.nameOffset;
+ if (offset == 0 && serializedExecutable != null) {
return serializedExecutable.nameOffset;
}
- return super.nameOffset;
+ return offset;
}
@override
@@ -4103,10 +4108,11 @@
@override
int get nameOffset {
- if (_unlinkedExportNonPublic != null) {
+ int offset = super.nameOffset;
+ if (offset == 0 && _unlinkedExportNonPublic != null) {
return _unlinkedExportNonPublic.offset;
}
- return super.nameOffset;
+ return offset;
}
@override
@@ -4676,10 +4682,11 @@
@override
int get nameOffset {
- if (_unlinkedTypedef != null) {
+ int offset = super.nameOffset;
+ if (offset == 0 && _unlinkedTypedef != null) {
return _unlinkedTypedef.nameOffset;
}
- return super.nameOffset;
+ return offset;
}
@override
@@ -5013,13 +5020,14 @@
@override
int get nameOffset {
- if (_unlinkedImport != null) {
+ int offset = super.nameOffset;
+ if (offset == 0 && _unlinkedImport != null) {
if (_unlinkedImport.isImplicit) {
return -1;
}
return _unlinkedImport.offset;
}
- return super.nameOffset;
+ return offset;
}
PrefixElement get prefix {
@@ -5222,10 +5230,13 @@
@override
int get nameOffset {
- if (_unlinkedLabel != null) {
+ int offset = super.nameOffset;
+ if (offset == 0 &&
+ _unlinkedLabel != null &&
+ _unlinkedLabel.nameOffset != 0) {
return _unlinkedLabel.nameOffset;
}
- return super.nameOffset;
+ return offset;
}
@override
@@ -6763,10 +6774,11 @@
@override
int get nameOffset {
- if (_unlinkedVariable != null) {
+ int offset = super.nameOffset;
+ if (offset == 0 && _unlinkedVariable != null) {
return _unlinkedVariable.nameOffset;
}
- return super.nameOffset;
+ return offset;
}
@override
@@ -7067,13 +7079,14 @@
@override
int get nameOffset {
- if (_unlinkedParam != null) {
+ int offset = super.nameOffset;
+ if (offset == 0 && _unlinkedParam != null) {
if (isSynthetic) {
return -1;
}
return _unlinkedParam.nameOffset;
}
- return super.nameOffset;
+ return offset;
}
@override
@@ -7389,10 +7402,11 @@
@override
int get nameOffset {
- if (_unlinkedImport != null) {
+ int offset = super.nameOffset;
+ if (offset == 0 && _unlinkedImport != null) {
return _unlinkedImport.prefixOffset;
}
- return super.nameOffset;
+ return offset;
}
@override
@@ -8037,10 +8051,11 @@
@override
int get nameOffset {
- if (_unlinkedTypeParam != null) {
+ int offset = super.nameOffset;
+ if (offset == 0 && _unlinkedTypeParam != null) {
return _unlinkedTypeParam.nameOffset;
}
- return super.nameOffset;
+ return offset;
}
TypeParameterType get type {
diff --git a/pkg/analyzer/lib/src/dart/error/hint_codes.dart b/pkg/analyzer/lib/src/dart/error/hint_codes.dart
new file mode 100644
index 0000000..ed8851b
--- /dev/null
+++ b/pkg/analyzer/lib/src/dart/error/hint_codes.dart
@@ -0,0 +1,571 @@
+// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library analyzer.src.dart.error.hint_codes;
+
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/src/dart/element/element.dart';
+
+/**
+ * The hints and coding recommendations for best practices which are not
+ * mentioned in the Dart Language Specification.
+ */
+class HintCode extends ErrorCode {
+ /**
+ * When an abstract supertype member is referenced with `super` as its target,
+ * it cannot be overridden, so it is always a runtime error.
+ *
+ * Parameters:
+ * 0: the display name for the kind of the referenced element
+ * 1: the name of the referenced element
+ */
+ static const HintCode ABSTRACT_SUPER_MEMBER_REFERENCE = const HintCode(
+ 'ABSTRACT_SUPER_MEMBER_REFERENCE',
+ "The {0} '{1}' is always abstract in the supertype.");
+
+ /**
+ * This hint is generated anywhere where the
+ * [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE] would have been generated,
+ * if we used propagated information for the warnings.
+ *
+ * Parameters:
+ * 0: the name of the actual argument type
+ * 1: the name of the expected type
+ */
+ static const HintCode ARGUMENT_TYPE_NOT_ASSIGNABLE = const HintCode(
+ 'ARGUMENT_TYPE_NOT_ASSIGNABLE',
+ "The argument type '{0}' can't be assigned to the parameter type '{1}'.");
+
+ /**
+ * When the target expression uses '?.' operator, it can be `null`, so all the
+ * subsequent invocations should also use '?.' operator.
+ */
+ static const HintCode CAN_BE_NULL_AFTER_NULL_AWARE = const HintCode(
+ 'CAN_BE_NULL_AFTER_NULL_AWARE',
+ "The target expression uses '?.', so its value can be null.",
+ "Replace the '.' with a '?.' in the invocation.");
+
+ /**
+ * Dead code is code that is never reached, this can happen for instance if a
+ * statement follows a return statement.
+ */
+ static const HintCode DEAD_CODE = const HintCode(
+ 'DEAD_CODE',
+ "Dead code.",
+ "Try removing the code, or "
+ "fixing the code before it so that it can be reached.");
+
+ /**
+ * Dead code is code that is never reached. This case covers cases where the
+ * user has catch clauses after `catch (e)` or `on Object catch (e)`.
+ */
+ static const HintCode DEAD_CODE_CATCH_FOLLOWING_CATCH = const HintCode(
+ 'DEAD_CODE_CATCH_FOLLOWING_CATCH',
+ "Dead code: catch clauses after a 'catch (e)' or "
+ "an 'on Object catch (e)' are never reached.",
+ "Try reordering the catch clauses so that they can be reached, or "
+ "removing the unreachable catch clauses.");
+
+ /**
+ * Dead code is code that is never reached. This case covers cases where the
+ * user has an on-catch clause such as `on A catch (e)`, where a supertype of
+ * `A` was already caught.
+ *
+ * Parameters:
+ * 0: name of the subtype
+ * 1: name of the supertype
+ */
+ static const HintCode DEAD_CODE_ON_CATCH_SUBTYPE = const HintCode(
+ 'DEAD_CODE_ON_CATCH_SUBTYPE',
+ "Dead code: this on-catch block will never be executed because '{0}' is "
+ "a subtype of '{1}' and hence will have been caught above.",
+ "Try reordering the catch clauses so that this block can be reached, or "
+ "removing the unreachable catch clause.");
+
+ /**
+ * Deprecated members should not be invoked or used.
+ *
+ * Parameters:
+ * 0: the name of the member
+ */
+ static const HintCode DEPRECATED_MEMBER_USE = const HintCode(
+ 'DEPRECATED_MEMBER_USE',
+ "'{0}' is deprecated and shouldn't be used.",
+ "Try replacing the use of the deprecated member with the replacement.");
+
+ /**
+ * Duplicate imports.
+ */
+ static const HintCode DUPLICATE_IMPORT = const HintCode('DUPLICATE_IMPORT',
+ "Duplicate import.", "Try removing all but one import of the library.");
+
+ /**
+ * Hint to use the ~/ operator.
+ */
+ static const HintCode DIVISION_OPTIMIZATION = const HintCode(
+ 'DIVISION_OPTIMIZATION',
+ "The operator x ~/ y is more efficient than (x / y).toInt().",
+ "Try re-writing the expression to use the '~/' operator.");
+
+ /**
+ * Hint for the `x is double` type checks.
+ */
+ static const HintCode IS_DOUBLE = const HintCode(
+ 'IS_DOUBLE',
+ "When compiled to JS, this test might return true when the left hand "
+ "side is an int.",
+ "Try testing for 'num' instead.");
+
+ /**
+ * Hint for the `x is int` type checks.
+ */
+ static const HintCode IS_INT = const HintCode(
+ 'IS_INT',
+ "When compiled to JS, this test might return true when the left hand "
+ "side is a double.",
+ "Try testing for 'num' instead.");
+
+ /**
+ * Hint for the `x is! double` type checks.
+ */
+ static const HintCode IS_NOT_DOUBLE = const HintCode(
+ 'IS_NOT_DOUBLE',
+ "When compiled to JS, this test might return false when the left hand "
+ "side is an int.",
+ "Try testing for 'num' instead.");
+
+ /**
+ * Hint for the `x is! int` type checks.
+ */
+ static const HintCode IS_NOT_INT = const HintCode(
+ 'IS_NOT_INT',
+ "When compiled to JS, this test might return false when the left hand "
+ "side is a double.",
+ "Try testing for 'num' instead.");
+
+ /**
+ * Deferred libraries shouldn't define a top level function 'loadLibrary'.
+ */
+ static const HintCode IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION =
+ const HintCode(
+ 'IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION',
+ "The library '{0}' defines a top-level function named 'loadLibrary' "
+ "which is hidden by deferring this library.",
+ "Try changing the import to not be deferred, or "
+ "rename the function in the imported library.");
+
+ /**
+ * This hint is generated anywhere where the
+ * [StaticTypeWarningCode.INVALID_ASSIGNMENT] would have been generated, if we
+ * used propagated information for the warnings.
+ *
+ * Parameters:
+ * 0: the name of the right hand side type
+ * 1: the name of the left hand side type
+ */
+ static const HintCode INVALID_ASSIGNMENT = const HintCode(
+ 'INVALID_ASSIGNMENT',
+ "A value of type '{0}' can't be assigned to a variable of type '{1}'.",
+ "Try changing the type of the variable, or "
+ "casting the right-hand type to '{1}'.");
+
+ /**
+ * This hint is generated anywhere a @factory annotation is associated with
+ * anything other than a method.
+ */
+ static const HintCode INVALID_FACTORY_ANNOTATION = const HintCode(
+ 'INVALID_FACTORY_ANNOTATION',
+ "Only methods can be annotated as factories.");
+
+ /**
+ * This hint is generated anywhere a @factory annotation is associated with
+ * a method that does not declare a return type.
+ */
+ static const HintCode INVALID_FACTORY_METHOD_DECL = const HintCode(
+ 'INVALID_FACTORY_METHOD_DECL',
+ "Factory method '{0}' must have a return type.");
+
+ /**
+ * This hint is generated anywhere a @factory annotation is associated with
+ * a non-abstract method that can return anything other than a newly allocated
+ * object.
+ *
+ * Parameters:
+ * 0: the name of the method
+ */
+ static const HintCode INVALID_FACTORY_METHOD_IMPL = const HintCode(
+ 'INVALID_FACTORY_METHOD_IMPL',
+ "Factory method '{0}' doesn't return a newly allocated object.");
+
+ /**
+ * This hint is generated anywhere where a member annotated with `@protected`
+ * is used outside an instance member of a subclass.
+ *
+ * Parameters:
+ * 0: the name of the member
+ * 1: the name of the defining class
+ */
+ static const HintCode INVALID_USE_OF_PROTECTED_MEMBER = const HintCode(
+ 'INVALID_USE_OF_PROTECTED_MEMBER',
+ "The member '{0}' can only be used within instance members of subclasses "
+ "of '{1}'.");
+
+ /**
+ * Generate a hint for a constructor, function or method invocation where a
+ * required parameter is missing.
+ *
+ * Parameters:
+ * 0: the name of the parameter
+ */
+ static const HintCode MISSING_REQUIRED_PARAM = const HintCode(
+ 'MISSING_REQUIRED_PARAM', "The parameter '{0}' is required.");
+
+ /**
+ * Generate a hint for a constructor, function or method invocation where a
+ * required parameter is missing.
+ *
+ * Parameters:
+ * 0: the name of the parameter
+ * 1: message details
+ */
+ static const HintCode MISSING_REQUIRED_PARAM_WITH_DETAILS = const HintCode(
+ 'MISSING_REQUIRED_PARAM_WITH_DETAILS',
+ "The parameter '{0}' is required. {1}.");
+
+ /**
+ * Generate a hint for an element that is annotated with `@JS(...)` whose
+ * library declaration is not similarly annotated.
+ */
+ static const HintCode MISSING_JS_LIB_ANNOTATION = const HintCode(
+ 'MISSING_JS_LIB_ANNOTATION',
+ "The @JS() annotation can only be used if it is also declared on the "
+ "library directive.",
+ "Try adding the annotation to the library directive.");
+
+ /**
+ * Generate a hint for methods or functions that have a return type, but do
+ * not have a non-void return statement on all branches. At the end of methods
+ * or functions with no return, Dart implicitly returns `null`, avoiding these
+ * implicit returns is considered a best practice.
+ *
+ * Parameters:
+ * 0: the name of the declared return type
+ */
+ static const HintCode MISSING_RETURN = const HintCode(
+ 'MISSING_RETURN',
+ "This function declares a return type of '{0}', but doesn't end with a "
+ "return statement.",
+ "Try adding a return statement, or changing the return type to 'void'.");
+
+ /**
+ * Generate a hint for methods that override methods annotated `@mustCallSuper`
+ * that do not invoke the overridden super method.
+ *
+ * Parameters:
+ * 0: the name of the class declaring the overriden method
+ */
+ static const HintCode MUST_CALL_SUPER = const HintCode(
+ 'MUST_CALL_SUPER',
+ "This method overrides a method annotated as @mustCall super in '{0}', "
+ "but does invoke the overriden method.");
+
+ /**
+ * A condition in a control flow statement could evaluate to `null` because it
+ * uses the null-aware '?.' operator.
+ */
+ static const HintCode NULL_AWARE_IN_CONDITION = const HintCode(
+ 'NULL_AWARE_IN_CONDITION',
+ "The value of the '?.' operator can be 'null', which isn't appropriate "
+ "in a condition.",
+ "Try replacing the '?.' with a '.', testing the left-hand side for null if "
+ "necessary.");
+
+ /**
+ * A getter with the override annotation does not override an existing getter.
+ */
+ static const HintCode OVERRIDE_ON_NON_OVERRIDING_GETTER = const HintCode(
+ 'OVERRIDE_ON_NON_OVERRIDING_GETTER',
+ "Getter doesn't override an inherited getter.",
+ "Try updating this class to match the superclass, or "
+ "removing the override annotation.");
+
+ /**
+ * A field with the override annotation does not override a getter or setter.
+ */
+ static const HintCode OVERRIDE_ON_NON_OVERRIDING_FIELD = const HintCode(
+ 'OVERRIDE_ON_NON_OVERRIDING_FIELD',
+ "Field doesn't override an inherited getter or setter.",
+ "Try updating this class to match the superclass, or "
+ "removing the override annotation.");
+
+ /**
+ * A method with the override annotation does not override an existing method.
+ */
+ static const HintCode OVERRIDE_ON_NON_OVERRIDING_METHOD = const HintCode(
+ 'OVERRIDE_ON_NON_OVERRIDING_METHOD',
+ "Method doesn't override an inherited method.",
+ "Try updating this class to match the superclass, or "
+ "removing the override annotation.");
+
+ /**
+ * A setter with the override annotation does not override an existing setter.
+ */
+ static const HintCode OVERRIDE_ON_NON_OVERRIDING_SETTER = const HintCode(
+ 'OVERRIDE_ON_NON_OVERRIDING_SETTER',
+ "Setter doesn't override an inherited setter.",
+ "Try updating this class to match the superclass, or "
+ "removing the override annotation.");
+
+ /**
+ * Hint for classes that override equals, but not hashCode.
+ *
+ * Parameters:
+ * 0: the name of the current class
+ */
+ static const HintCode OVERRIDE_EQUALS_BUT_NOT_HASH_CODE = const HintCode(
+ 'OVERRIDE_EQUALS_BUT_NOT_HASH_CODE',
+ "The class '{0}' overrides 'operator==', but not 'get hashCode'.",
+ "Try implementing 'hashCode'.");
+
+ /**
+ * Type checks of the type `x is! Null` should be done with `x != null`.
+ */
+ static const HintCode TYPE_CHECK_IS_NOT_NULL = const HintCode(
+ 'TYPE_CHECK_IS_NOT_NULL',
+ "Tests for non-null should be done with '!= null'.",
+ "Try replacing the 'is! Null' check with '!= null'.");
+
+ /**
+ * Type checks of the type `x is Null` should be done with `x == null`.
+ */
+ static const HintCode TYPE_CHECK_IS_NULL = const HintCode(
+ 'TYPE_CHECK_IS_NULL',
+ "Tests for null should be done with '== null'.",
+ "Try replacing the 'is Null' check with '== null'.");
+
+ /**
+ * This hint is generated anywhere where the
+ * [StaticTypeWarningCode.UNDEFINED_GETTER] or
+ * [StaticWarningCode.UNDEFINED_GETTER] would have been generated, if we used
+ * propagated information for the warnings.
+ *
+ * Parameters:
+ * 0: the name of the getter
+ * 1: the name of the enclosing type where the getter is being looked for
+ */
+ static const HintCode UNDEFINED_GETTER = const HintCode(
+ 'UNDEFINED_GETTER',
+ "The getter '{0}' isn't defined for the class '{1}'.",
+ "Try defining a getter or field named '{0}', or invoke a different getter.");
+
+ /**
+ * An undefined name hidden in an import or export directive.
+ */
+ static const HintCode UNDEFINED_HIDDEN_NAME = const HintCode(
+ 'UNDEFINED_HIDDEN_NAME',
+ "The library '{0}' doesn't export a member with the hidden name '{1}'.",
+ "Try removing the name from the list of hidden members.");
+
+ /**
+ * This hint is generated anywhere where the
+ * [StaticTypeWarningCode.UNDEFINED_METHOD] would have been generated, if we
+ * used propagated information for the warnings.
+ *
+ * Parameters:
+ * 0: the name of the method that is undefined
+ * 1: the resolved type name that the method lookup is happening on
+ */
+ static const HintCode UNDEFINED_METHOD = const HintCode(
+ 'UNDEFINED_METHOD',
+ "The method '{0}' isn't defined for the class '{1}'.",
+ "Try correcting the name to the name of an existing method, or"
+ "defining a method named '{0}'.");
+
+ /**
+ * This hint is generated anywhere where the
+ * [StaticTypeWarningCode.UNDEFINED_OPERATOR] would have been generated, if we
+ * used propagated information for the warnings.
+ *
+ * Parameters:
+ * 0: the name of the operator
+ * 1: the name of the enclosing type where the operator is being looked for
+ */
+ static const HintCode UNDEFINED_OPERATOR = const HintCode(
+ 'UNDEFINED_OPERATOR',
+ "The operator '{0}' isn't defined for the class '{1}'.",
+ "Try defining the operator '{0}'.");
+
+ /**
+ * This hint is generated anywhere where the
+ * [StaticTypeWarningCode.UNDEFINED_SETTER] or
+ * [StaticWarningCode.UNDEFINED_SETTER] would have been generated, if we used
+ * propagated information for the warnings.
+ *
+ * Parameters:
+ * 0: the name of the setter
+ * 1: the name of the enclosing type where the setter is being looked for
+ */
+ static const HintCode UNDEFINED_SETTER = const HintCode(
+ 'UNDEFINED_SETTER',
+ "The setter '{0}' isn't defined for the class '{1}'.",
+ "Try defining a setter or field named '{0}', or invoke a different setter.");
+
+ /**
+ * An undefined name shown in an import or export directive.
+ */
+ static const HintCode UNDEFINED_SHOWN_NAME = const HintCode(
+ 'UNDEFINED_SHOWN_NAME',
+ "The library '{0}' doesn't export a member with the shown name '{1}'.",
+ "Try removing the name from the list of shown members.");
+
+ /**
+ * Unnecessary cast.
+ */
+ static const HintCode UNNECESSARY_CAST = const HintCode(
+ 'UNNECESSARY_CAST', "Unnecessary cast.", "Try removing the cast.");
+
+ /**
+ * Unnecessary `noSuchMethod` declaration.
+ */
+ static const HintCode UNNECESSARY_NO_SUCH_METHOD = const HintCode(
+ 'UNNECESSARY_NO_SUCH_METHOD',
+ "Unnecessary 'noSuchMethod' declaration.",
+ "Try removing the declaration of 'noSuchMethod'.");
+
+ /**
+ * Unnecessary type checks, the result is always false.
+ */
+ static const HintCode UNNECESSARY_TYPE_CHECK_FALSE = const HintCode(
+ 'UNNECESSARY_TYPE_CHECK_FALSE',
+ "Unnecessary type check, the result is always false.",
+ "Try correcting the type check, or removing the type check.");
+
+ /**
+ * Unnecessary type checks, the result is always true.
+ */
+ static const HintCode UNNECESSARY_TYPE_CHECK_TRUE = const HintCode(
+ 'UNNECESSARY_TYPE_CHECK_TRUE',
+ "Unnecessary type check, the result is always true.",
+ "Try correcting the type check, or removing the type check.");
+
+ /**
+ * See [Modifier.IS_USED_IN_LIBRARY].
+ */
+ static const HintCode UNUSED_ELEMENT = const HintCode('UNUSED_ELEMENT',
+ "The {0} '{1}' isn't used.", "Try removing the declaration of '{1}'.");
+
+ /**
+ * Unused fields are fields which are never read.
+ */
+ static const HintCode UNUSED_FIELD = const HintCode(
+ 'UNUSED_FIELD',
+ "The value of the field '{0}' isn't used.",
+ "Try removing the field, or using it.");
+
+ /**
+ * Unused imports are imports which are never used.
+ */
+ static const HintCode UNUSED_IMPORT = const HintCode(
+ 'UNUSED_IMPORT', "Unused import.", "Try removing the import directive.");
+
+ /**
+ * Unused catch exception variables.
+ */
+ static const HintCode UNUSED_CATCH_CLAUSE = const HintCode(
+ 'UNUSED_CATCH_CLAUSE',
+ "The exception variable '{0}' isn't used, so the 'catch' clause can be removed.",
+ // TODO(brianwilkerson) Split this error code so that we can differentiate
+ // between removing the catch clause and replacing the catch clause with
+ // an on clause.
+ "Try removing the catch clause.");
+
+ /**
+ * Unused catch stack trace variables.
+ */
+ static const HintCode UNUSED_CATCH_STACK = const HintCode(
+ 'UNUSED_CATCH_STACK',
+ "The stack trace variable '{0}' isn't used and can be removed.",
+ "Try removing the stack trace variable, or using it.");
+
+ /**
+ * Unused local variables are local variables which are never read.
+ */
+ static const HintCode UNUSED_LOCAL_VARIABLE = const HintCode(
+ 'UNUSED_LOCAL_VARIABLE',
+ "The value of the local variable '{0}' isn't used.",
+ "Try removing the variable, or using it.");
+
+ /**
+ * Unused shown names are names shown on imports which are never used.
+ */
+ static const HintCode UNUSED_SHOWN_NAME = const HintCode(
+ 'UNUSED_SHOWN_NAME',
+ "The name {0} is shown, but not used.",
+ "Try removing the name from the list of shown members.");
+
+ /**
+ * Hint for cases where the source expects a method or function to return a
+ * non-void result, but the method or function signature returns void.
+ *
+ * Parameters:
+ * 0: the name of the method or function that returns void
+ */
+ static const HintCode USE_OF_VOID_RESULT = const HintCode(
+ 'USE_OF_VOID_RESULT',
+ "The result of '{0}' is being used, even though it is declared to be 'void'.");
+
+ /**
+ * It is a bad practice for a source file in a package "lib" directory
+ * hierarchy to traverse outside that directory hierarchy. For example, a
+ * source file in the "lib" directory should not contain a directive such as
+ * `import '../web/some.dart'` which references a file outside the lib
+ * directory.
+ */
+ static const HintCode FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE =
+ const HintCode(
+ 'FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE',
+ "A file in the 'lib' directory shouldn't import a file outside the "
+ "'lib' directory.",
+ "Try removing the import, or "
+ "moving the imported file inside the 'lib' directory.");
+
+ /**
+ * It is a bad practice for a source file ouside a package "lib" directory
+ * hierarchy to traverse into that directory hierarchy. For example, a source
+ * file in the "web" directory should not contain a directive such as
+ * `import '../lib/some.dart'` which references a file inside the lib
+ * directory.
+ */
+ static const HintCode FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE =
+ const HintCode(
+ 'FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE',
+ "A file outside the 'lib' directory shouldn't reference a file "
+ "inside the 'lib' directory using a relative path.",
+ "Try using a package: URI instead.");
+
+ /**
+ * It is a bad practice for a package import to reference anything outside the
+ * given package, or more generally, it is bad practice for a package import
+ * to contain a "..". For example, a source file should not contain a
+ * directive such as `import 'package:foo/../some.dart'`.
+ */
+ static const HintCode PACKAGE_IMPORT_CONTAINS_DOT_DOT = const HintCode(
+ 'PACKAGE_IMPORT_CONTAINS_DOT_DOT',
+ "A package import shouldn't contain '..'.");
+
+ /**
+ * Initialize a newly created error code to have the given [name]. The message
+ * associated with the error will be created from the given [message]
+ * template. The correction associated with the error will be created from the
+ * given [correction] template.
+ */
+ const HintCode(String name, String message, [String correction])
+ : super(name, message, correction);
+
+ @override
+ ErrorSeverity get errorSeverity => ErrorType.HINT.severity;
+
+ @override
+ ErrorType get type => ErrorType.HINT;
+}
diff --git a/pkg/analyzer/lib/src/dart/error/lint_codes.dart b/pkg/analyzer/lib/src/dart/error/lint_codes.dart
new file mode 100644
index 0000000..0fd6824
--- /dev/null
+++ b/pkg/analyzer/lib/src/dart/error/lint_codes.dart
@@ -0,0 +1,25 @@
+// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library analyzer.src.dart.error.lint_codes;
+
+import 'package:analyzer/error/error.dart';
+
+/**
+ * Defines style and best practice recommendations.
+ *
+ * Unlike [HintCode]s, which are akin to traditional static warnings from a
+ * compiler, lint recommendations focus on matters of style and practices that
+ * might aggregated to define a project's style guide.
+ */
+class LintCode extends ErrorCode {
+ const LintCode(String name, String message, [String correction])
+ : super(name, message, correction);
+
+ @override
+ ErrorSeverity get errorSeverity => ErrorSeverity.INFO;
+
+ @override
+ ErrorType get type => ErrorType.LINT;
+}
diff --git a/pkg/analyzer/lib/src/dart/error/todo_codes.dart b/pkg/analyzer/lib/src/dart/error/todo_codes.dart
new file mode 100644
index 0000000..3980f57
--- /dev/null
+++ b/pkg/analyzer/lib/src/dart/error/todo_codes.dart
@@ -0,0 +1,45 @@
+// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library analyzer.src.dart.error.todo_codes;
+
+import 'package:analyzer/error/error.dart';
+
+/**
+ * The error code indicating a marker in code for work that needs to be finished
+ * or revisited.
+ */
+class TodoCode extends ErrorCode {
+ /**
+ * The single enum of TodoCode.
+ */
+ static const TodoCode TODO = const TodoCode('TODO');
+
+ /**
+ * This matches the two common Dart task styles
+ *
+ * * TODO:
+ * * TODO(username):
+ *
+ * As well as
+ * * TODO
+ *
+ * But not
+ * * todo
+ * * TODOS
+ */
+ static RegExp TODO_REGEX =
+ new RegExp("([\\s/\\*])((TODO[^\\w\\d][^\\r\\n]*)|(TODO:?\$))");
+
+ /**
+ * Initialize a newly created error code to have the given [name].
+ */
+ const TodoCode(String name) : super(name, "{0}");
+
+ @override
+ ErrorSeverity get errorSeverity => ErrorSeverity.INFO;
+
+ @override
+ ErrorType get type => ErrorType.TODO;
+}
diff --git a/pkg/analyzer/lib/src/error/codes.dart b/pkg/analyzer/lib/src/error/codes.dart
index 812d030..e04d6f3 100644
--- a/pkg/analyzer/lib/src/error/codes.dart
+++ b/pkg/analyzer/lib/src/error/codes.dart
@@ -5,114 +5,12 @@
library analyzer.src.error.codes;
import 'package:analyzer/error/error.dart';
-import 'package:analyzer/src/dart/element/element.dart';
-/**
- * The error codes used for errors in analysis options files. The convention for
- * this class is for the name of the error code to indicate the problem that
- * caused the error to be generated and for the error message to explain what is
- * wrong and, when appropriate, how the problem can be corrected.
- */
-class AnalysisOptionsErrorCode extends ErrorCode {
- /**
- * An error code indicating that there is a syntactic error in the file.
- *
- * Parameters:
- * 0: the error message from the parse error
- */
- static const AnalysisOptionsErrorCode PARSE_ERROR =
- const AnalysisOptionsErrorCode('PARSE_ERROR', '{0}');
-
- /**
- * Initialize a newly created error code to have the given [name].
- */
- const AnalysisOptionsErrorCode(String name, String message,
- [String correction])
- : super(name, message, correction);
-
- @override
- ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
-
- @override
- ErrorType get type => ErrorType.COMPILE_TIME_ERROR;
-}
-
-/**
- * The error codes used for warnings in analysis options files. The convention
- * for this class is for the name of the error code to indicate the problem that
- * caused the error to be generated and for the error message to explain what is
- * wrong and, when appropriate, how the problem can be corrected.
- */
-class AnalysisOptionsWarningCode extends ErrorCode {
- /**
- * An error code indicating that a plugin is being configured with an
- * unsupported option and legal options are provided.
- *
- * Parameters:
- * 0: the plugin name
- * 1: the unsupported option key
- * 2: legal values
- */
- static const AnalysisOptionsWarningCode UNSUPPORTED_OPTION_WITH_LEGAL_VALUES =
- const AnalysisOptionsWarningCode(
- 'UNSUPPORTED_OPTION_WITH_LEGAL_VALUES',
- "The option '{1}' isn't supported by '{0}'.",
- "Try using one of the supported options: {2}.");
-
- /**
- * An error code indicating that a plugin is being configured with an
- * unsupported option where there is just one legal value.
- *
- * Parameters:
- * 0: the plugin name
- * 1: the unsupported option key
- * 2: the legal value
- */
- static const AnalysisOptionsWarningCode UNSUPPORTED_OPTION_WITH_LEGAL_VALUE =
- const AnalysisOptionsWarningCode(
- 'UNSUPPORTED_OPTION_WITH_LEGAL_VALUE',
- "The option '{1}' isn't supported by '{0}'."
- "Try using the only supported option: '{2}'.");
-
- /**
- * An error code indicating that an option entry is being configured with an
- * unsupported value.
- *
- * Parameters:
- * 0: the option name
- * 1: the unsupported value
- * 2: legal values
- */
- static const AnalysisOptionsWarningCode UNSUPPORTED_VALUE =
- const AnalysisOptionsWarningCode(
- 'UNSUPPORTED_VALUE',
- "The value '{1}' isn't supported by '{0}'.",
- "Try using one of the supported options: {2}.");
-
- /**
- * An error code indicating that an unrecognized error code is being used to
- * specify an error filter.
- *
- * Parameters:
- * 0: the unrecognized error code
- */
- static const AnalysisOptionsWarningCode UNRECOGNIZED_ERROR_CODE =
- const AnalysisOptionsWarningCode(
- 'UNRECOGNIZED_ERROR_CODE', "'{0}' isn't a recognized error code.");
-
- /**
- * Initialize a newly created warning code to have the given [name].
- */
- const AnalysisOptionsWarningCode(String name, String message,
- [String correction])
- : super(name, message, correction);
-
- @override
- ErrorSeverity get errorSeverity => ErrorSeverity.WARNING;
-
- @override
- ErrorType get type => ErrorType.STATIC_WARNING;
-}
+export 'package:analyzer/src/analysis_options/error/option_codes.dart';
+export 'package:analyzer/src/dart/error/hint_codes.dart';
+export 'package:analyzer/src/dart/error/lint_codes.dart';
+export 'package:analyzer/src/dart/error/todo_codes.dart';
+export 'package:analyzer/src/html/error/html_codes.dart';
/**
* The error codes used for compile time errors caused by constant evaluation
@@ -2616,662 +2514,6 @@
}
/**
- * The hints and coding recommendations for best practices which are not
- * mentioned in the Dart Language Specification.
- */
-class HintCode extends ErrorCode {
- /**
- * When an abstract supertype member is referenced with `super` as its target,
- * it cannot be overridden, so it is always a runtime error.
- *
- * Parameters:
- * 0: the display name for the kind of the referenced element
- * 1: the name of the referenced element
- */
- static const HintCode ABSTRACT_SUPER_MEMBER_REFERENCE = const HintCode(
- 'ABSTRACT_SUPER_MEMBER_REFERENCE',
- "The {0} '{1}' is always abstract in the supertype.");
-
- /**
- * This hint is generated anywhere where the
- * [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE] would have been generated,
- * if we used propagated information for the warnings.
- *
- * Parameters:
- * 0: the name of the actual argument type
- * 1: the name of the expected type
- */
- static const HintCode ARGUMENT_TYPE_NOT_ASSIGNABLE = const HintCode(
- 'ARGUMENT_TYPE_NOT_ASSIGNABLE',
- "The argument type '{0}' can't be assigned to the parameter type '{1}'.");
-
- /**
- * When the target expression uses '?.' operator, it can be `null`, so all the
- * subsequent invocations should also use '?.' operator.
- */
- static const HintCode CAN_BE_NULL_AFTER_NULL_AWARE = const HintCode(
- 'CAN_BE_NULL_AFTER_NULL_AWARE',
- "The target expression uses '?.', so its value can be null.",
- "Replace the '.' with a '?.' in the invocation.");
-
- /**
- * Dead code is code that is never reached, this can happen for instance if a
- * statement follows a return statement.
- */
- static const HintCode DEAD_CODE = const HintCode(
- 'DEAD_CODE',
- "Dead code.",
- "Try removing the code, or "
- "fixing the code before it so that it can be reached.");
-
- /**
- * Dead code is code that is never reached. This case covers cases where the
- * user has catch clauses after `catch (e)` or `on Object catch (e)`.
- */
- static const HintCode DEAD_CODE_CATCH_FOLLOWING_CATCH = const HintCode(
- 'DEAD_CODE_CATCH_FOLLOWING_CATCH',
- "Dead code: catch clauses after a 'catch (e)' or "
- "an 'on Object catch (e)' are never reached.",
- "Try reordering the catch clauses so that they can be reached, or "
- "removing the unreachable catch clauses.");
-
- /**
- * Dead code is code that is never reached. This case covers cases where the
- * user has an on-catch clause such as `on A catch (e)`, where a supertype of
- * `A` was already caught.
- *
- * Parameters:
- * 0: name of the subtype
- * 1: name of the supertype
- */
- static const HintCode DEAD_CODE_ON_CATCH_SUBTYPE = const HintCode(
- 'DEAD_CODE_ON_CATCH_SUBTYPE',
- "Dead code: this on-catch block will never be executed because '{0}' is "
- "a subtype of '{1}' and hence will have been caught above.",
- "Try reordering the catch clauses so that this block can be reached, or "
- "removing the unreachable catch clause.");
-
- /**
- * Deprecated members should not be invoked or used.
- *
- * Parameters:
- * 0: the name of the member
- */
- static const HintCode DEPRECATED_MEMBER_USE = const HintCode(
- 'DEPRECATED_MEMBER_USE',
- "'{0}' is deprecated and shouldn't be used.",
- "Try replacing the use of the deprecated member with the replacement.");
-
- /**
- * Duplicate imports.
- */
- static const HintCode DUPLICATE_IMPORT = const HintCode('DUPLICATE_IMPORT',
- "Duplicate import.", "Try removing all but one import of the library.");
-
- /**
- * Hint to use the ~/ operator.
- */
- static const HintCode DIVISION_OPTIMIZATION = const HintCode(
- 'DIVISION_OPTIMIZATION',
- "The operator x ~/ y is more efficient than (x / y).toInt().",
- "Try re-writing the expression to use the '~/' operator.");
-
- /**
- * Hint for the `x is double` type checks.
- */
- static const HintCode IS_DOUBLE = const HintCode(
- 'IS_DOUBLE',
- "When compiled to JS, this test might return true when the left hand "
- "side is an int.",
- "Try testing for 'num' instead.");
-
- /**
- * Hint for the `x is int` type checks.
- */
- static const HintCode IS_INT = const HintCode(
- 'IS_INT',
- "When compiled to JS, this test might return true when the left hand "
- "side is a double.",
- "Try testing for 'num' instead.");
-
- /**
- * Hint for the `x is! double` type checks.
- */
- static const HintCode IS_NOT_DOUBLE = const HintCode(
- 'IS_NOT_DOUBLE',
- "When compiled to JS, this test might return false when the left hand "
- "side is an int.",
- "Try testing for 'num' instead.");
-
- /**
- * Hint for the `x is! int` type checks.
- */
- static const HintCode IS_NOT_INT = const HintCode(
- 'IS_NOT_INT',
- "When compiled to JS, this test might return false when the left hand "
- "side is a double.",
- "Try testing for 'num' instead.");
-
- /**
- * Deferred libraries shouldn't define a top level function 'loadLibrary'.
- */
- static const HintCode IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION =
- const HintCode(
- 'IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION',
- "The library '{0}' defines a top-level function named 'loadLibrary' "
- "which is hidden by deferring this library.",
- "Try changing the import to not be deferred, or "
- "rename the function in the imported library.");
-
- /**
- * This hint is generated anywhere where the
- * [StaticTypeWarningCode.INVALID_ASSIGNMENT] would have been generated, if we
- * used propagated information for the warnings.
- *
- * Parameters:
- * 0: the name of the right hand side type
- * 1: the name of the left hand side type
- */
- static const HintCode INVALID_ASSIGNMENT = const HintCode(
- 'INVALID_ASSIGNMENT',
- "A value of type '{0}' can't be assigned to a variable of type '{1}'.",
- "Try changing the type of the variable, or "
- "casting the right-hand type to '{1}'.");
-
- /**
- * This hint is generated anywhere a @factory annotation is associated with
- * anything other than a method.
- */
- static const HintCode INVALID_FACTORY_ANNOTATION = const HintCode(
- 'INVALID_FACTORY_ANNOTATION',
- "Only methods can be annotated as factories.");
-
- /**
- * This hint is generated anywhere a @factory annotation is associated with
- * a method that does not declare a return type.
- */
- static const HintCode INVALID_FACTORY_METHOD_DECL = const HintCode(
- 'INVALID_FACTORY_METHOD_DECL',
- "Factory method '{0}' must have a return type.");
-
- /**
- * This hint is generated anywhere a @factory annotation is associated with
- * a non-abstract method that can return anything other than a newly allocated
- * object.
- *
- * Parameters:
- * 0: the name of the method
- */
- static const HintCode INVALID_FACTORY_METHOD_IMPL = const HintCode(
- 'INVALID_FACTORY_METHOD_IMPL',
- "Factory method '{0}' doesn't return a newly allocated object.");
-
- /**
- * This hint is generated anywhere where a member annotated with `@protected`
- * is used outside an instance member of a subclass.
- *
- * Parameters:
- * 0: the name of the member
- * 1: the name of the defining class
- */
- static const HintCode INVALID_USE_OF_PROTECTED_MEMBER = const HintCode(
- 'INVALID_USE_OF_PROTECTED_MEMBER',
- "The member '{0}' can only be used within instance members of subclasses "
- "of '{1}'.");
-
- /**
- * Generate a hint for a constructor, function or method invocation where a
- * required parameter is missing.
- *
- * Parameters:
- * 0: the name of the parameter
- */
- static const HintCode MISSING_REQUIRED_PARAM = const HintCode(
- 'MISSING_REQUIRED_PARAM', "The parameter '{0}' is required.");
-
- /**
- * Generate a hint for a constructor, function or method invocation where a
- * required parameter is missing.
- *
- * Parameters:
- * 0: the name of the parameter
- * 1: message details
- */
- static const HintCode MISSING_REQUIRED_PARAM_WITH_DETAILS = const HintCode(
- 'MISSING_REQUIRED_PARAM_WITH_DETAILS',
- "The parameter '{0}' is required. {1}.");
-
- /**
- * Generate a hint for an element that is annotated with `@JS(...)` whose
- * library declaration is not similarly annotated.
- */
- static const HintCode MISSING_JS_LIB_ANNOTATION = const HintCode(
- 'MISSING_JS_LIB_ANNOTATION',
- "The @JS() annotation can only be used if it is also declared on the "
- "library directive.",
- "Try adding the annotation to the library directive.");
-
- /**
- * Generate a hint for methods or functions that have a return type, but do
- * not have a non-void return statement on all branches. At the end of methods
- * or functions with no return, Dart implicitly returns `null`, avoiding these
- * implicit returns is considered a best practice.
- *
- * Parameters:
- * 0: the name of the declared return type
- */
- static const HintCode MISSING_RETURN = const HintCode(
- 'MISSING_RETURN',
- "This function declares a return type of '{0}', but doesn't end with a "
- "return statement.",
- "Try adding a return statement, or changing the return type to 'void'.");
-
- /**
- * Generate a hint for methods that override methods annotated `@mustCallSuper`
- * that do not invoke the overridden super method.
- *
- * Parameters:
- * 0: the name of the class declaring the overriden method
- */
- static const HintCode MUST_CALL_SUPER = const HintCode(
- 'MUST_CALL_SUPER',
- "This method overrides a method annotated as @mustCall super in '{0}', "
- "but does invoke the overriden method.");
-
- /**
- * A condition in a control flow statement could evaluate to `null` because it
- * uses the null-aware '?.' operator.
- */
- static const HintCode NULL_AWARE_IN_CONDITION = const HintCode(
- 'NULL_AWARE_IN_CONDITION',
- "The value of the '?.' operator can be 'null', which isn't appropriate "
- "in a condition.",
- "Try replacing the '?.' with a '.', testing the left-hand side for null if "
- "necessary.");
-
- /**
- * A getter with the override annotation does not override an existing getter.
- */
- static const HintCode OVERRIDE_ON_NON_OVERRIDING_GETTER = const HintCode(
- 'OVERRIDE_ON_NON_OVERRIDING_GETTER',
- "Getter doesn't override an inherited getter.",
- "Try updating this class to match the superclass, or "
- "removing the override annotation.");
-
- /**
- * A field with the override annotation does not override a getter or setter.
- */
- static const HintCode OVERRIDE_ON_NON_OVERRIDING_FIELD = const HintCode(
- 'OVERRIDE_ON_NON_OVERRIDING_FIELD',
- "Field doesn't override an inherited getter or setter.",
- "Try updating this class to match the superclass, or "
- "removing the override annotation.");
-
- /**
- * A method with the override annotation does not override an existing method.
- */
- static const HintCode OVERRIDE_ON_NON_OVERRIDING_METHOD = const HintCode(
- 'OVERRIDE_ON_NON_OVERRIDING_METHOD',
- "Method doesn't override an inherited method.",
- "Try updating this class to match the superclass, or "
- "removing the override annotation.");
-
- /**
- * A setter with the override annotation does not override an existing setter.
- */
- static const HintCode OVERRIDE_ON_NON_OVERRIDING_SETTER = const HintCode(
- 'OVERRIDE_ON_NON_OVERRIDING_SETTER',
- "Setter doesn't override an inherited setter.",
- "Try updating this class to match the superclass, or "
- "removing the override annotation.");
-
- /**
- * Hint for classes that override equals, but not hashCode.
- *
- * Parameters:
- * 0: the name of the current class
- */
- static const HintCode OVERRIDE_EQUALS_BUT_NOT_HASH_CODE = const HintCode(
- 'OVERRIDE_EQUALS_BUT_NOT_HASH_CODE',
- "The class '{0}' overrides 'operator==', but not 'get hashCode'.",
- "Try implementing 'hashCode'.");
-
- /**
- * Type checks of the type `x is! Null` should be done with `x != null`.
- */
- static const HintCode TYPE_CHECK_IS_NOT_NULL = const HintCode(
- 'TYPE_CHECK_IS_NOT_NULL',
- "Tests for non-null should be done with '!= null'.",
- "Try replacing the 'is! Null' check with '!= null'.");
-
- /**
- * Type checks of the type `x is Null` should be done with `x == null`.
- */
- static const HintCode TYPE_CHECK_IS_NULL = const HintCode(
- 'TYPE_CHECK_IS_NULL',
- "Tests for null should be done with '== null'.",
- "Try replacing the 'is Null' check with '== null'.");
-
- /**
- * This hint is generated anywhere where the
- * [StaticTypeWarningCode.UNDEFINED_GETTER] or
- * [StaticWarningCode.UNDEFINED_GETTER] would have been generated, if we used
- * propagated information for the warnings.
- *
- * Parameters:
- * 0: the name of the getter
- * 1: the name of the enclosing type where the getter is being looked for
- */
- static const HintCode UNDEFINED_GETTER = const HintCode(
- 'UNDEFINED_GETTER',
- "The getter '{0}' isn't defined for the class '{1}'.",
- "Try defining a getter or field named '{0}', or invoke a different getter.");
-
- /**
- * An undefined name hidden in an import or export directive.
- */
- static const HintCode UNDEFINED_HIDDEN_NAME = const HintCode(
- 'UNDEFINED_HIDDEN_NAME',
- "The library '{0}' doesn't export a member with the hidden name '{1}'.",
- "Try removing the name from the list of hidden members.");
-
- /**
- * This hint is generated anywhere where the
- * [StaticTypeWarningCode.UNDEFINED_METHOD] would have been generated, if we
- * used propagated information for the warnings.
- *
- * Parameters:
- * 0: the name of the method that is undefined
- * 1: the resolved type name that the method lookup is happening on
- */
- static const HintCode UNDEFINED_METHOD = const HintCode(
- 'UNDEFINED_METHOD',
- "The method '{0}' isn't defined for the class '{1}'.",
- "Try correcting the name to the name of an existing method, or"
- "defining a method named '{0}'.");
-
- /**
- * This hint is generated anywhere where the
- * [StaticTypeWarningCode.UNDEFINED_OPERATOR] would have been generated, if we
- * used propagated information for the warnings.
- *
- * Parameters:
- * 0: the name of the operator
- * 1: the name of the enclosing type where the operator is being looked for
- */
- static const HintCode UNDEFINED_OPERATOR = const HintCode(
- 'UNDEFINED_OPERATOR',
- "The operator '{0}' isn't defined for the class '{1}'.",
- "Try defining the operator '{0}'.");
-
- /**
- * This hint is generated anywhere where the
- * [StaticTypeWarningCode.UNDEFINED_SETTER] or
- * [StaticWarningCode.UNDEFINED_SETTER] would have been generated, if we used
- * propagated information for the warnings.
- *
- * Parameters:
- * 0: the name of the setter
- * 1: the name of the enclosing type where the setter is being looked for
- */
- static const HintCode UNDEFINED_SETTER = const HintCode(
- 'UNDEFINED_SETTER',
- "The setter '{0}' isn't defined for the class '{1}'.",
- "Try defining a setter or field named '{0}', or invoke a different setter.");
-
- /**
- * An undefined name shown in an import or export directive.
- */
- static const HintCode UNDEFINED_SHOWN_NAME = const HintCode(
- 'UNDEFINED_SHOWN_NAME',
- "The library '{0}' doesn't export a member with the shown name '{1}'.",
- "Try removing the name from the list of shown members.");
-
- /**
- * Unnecessary cast.
- */
- static const HintCode UNNECESSARY_CAST = const HintCode(
- 'UNNECESSARY_CAST', "Unnecessary cast.", "Try removing the cast.");
-
- /**
- * Unnecessary `noSuchMethod` declaration.
- */
- static const HintCode UNNECESSARY_NO_SUCH_METHOD = const HintCode(
- 'UNNECESSARY_NO_SUCH_METHOD',
- "Unnecessary 'noSuchMethod' declaration.",
- "Try removing the declaration of 'noSuchMethod'.");
-
- /**
- * Unnecessary type checks, the result is always false.
- */
- static const HintCode UNNECESSARY_TYPE_CHECK_FALSE = const HintCode(
- 'UNNECESSARY_TYPE_CHECK_FALSE',
- "Unnecessary type check, the result is always false.",
- "Try correcting the type check, or removing the type check.");
-
- /**
- * Unnecessary type checks, the result is always true.
- */
- static const HintCode UNNECESSARY_TYPE_CHECK_TRUE = const HintCode(
- 'UNNECESSARY_TYPE_CHECK_TRUE',
- "Unnecessary type check, the result is always true.",
- "Try correcting the type check, or removing the type check.");
-
- /**
- * See [Modifier.IS_USED_IN_LIBRARY].
- */
- static const HintCode UNUSED_ELEMENT = const HintCode('UNUSED_ELEMENT',
- "The {0} '{1}' isn't used.", "Try removing the declaration of '{1}'.");
-
- /**
- * Unused fields are fields which are never read.
- */
- static const HintCode UNUSED_FIELD = const HintCode(
- 'UNUSED_FIELD',
- "The value of the field '{0}' isn't used.",
- "Try removing the field, or using it.");
-
- /**
- * Unused imports are imports which are never used.
- */
- static const HintCode UNUSED_IMPORT = const HintCode(
- 'UNUSED_IMPORT', "Unused import.", "Try removing the import directive.");
-
- /**
- * Unused catch exception variables.
- */
- static const HintCode UNUSED_CATCH_CLAUSE = const HintCode(
- 'UNUSED_CATCH_CLAUSE',
- "The exception variable '{0}' isn't used, so the 'catch' clause can be removed.",
- // TODO(brianwilkerson) Split this error code so that we can differentiate
- // between removing the catch clause and replacing the catch clause with
- // an on clause.
- "Try removing the catch clause.");
-
- /**
- * Unused catch stack trace variables.
- */
- static const HintCode UNUSED_CATCH_STACK = const HintCode(
- 'UNUSED_CATCH_STACK',
- "The stack trace variable '{0}' isn't used and can be removed.",
- "Try removing the stack trace variable, or using it.");
-
- /**
- * Unused local variables are local variables which are never read.
- */
- static const HintCode UNUSED_LOCAL_VARIABLE = const HintCode(
- 'UNUSED_LOCAL_VARIABLE',
- "The value of the local variable '{0}' isn't used.",
- "Try removing the variable, or using it.");
-
- /**
- * Unused shown names are names shown on imports which are never used.
- */
- static const HintCode UNUSED_SHOWN_NAME = const HintCode(
- 'UNUSED_SHOWN_NAME',
- "The name {0} is shown, but not used.",
- "Try removing the name from the list of shown members.");
-
- /**
- * Hint for cases where the source expects a method or function to return a
- * non-void result, but the method or function signature returns void.
- *
- * Parameters:
- * 0: the name of the method or function that returns void
- */
- static const HintCode USE_OF_VOID_RESULT = const HintCode(
- 'USE_OF_VOID_RESULT',
- "The result of '{0}' is being used, even though it is declared to be 'void'.");
-
- /**
- * It is a bad practice for a source file in a package "lib" directory
- * hierarchy to traverse outside that directory hierarchy. For example, a
- * source file in the "lib" directory should not contain a directive such as
- * `import '../web/some.dart'` which references a file outside the lib
- * directory.
- */
- static const HintCode FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE =
- const HintCode(
- 'FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE',
- "A file in the 'lib' directory shouldn't import a file outside the "
- "'lib' directory.",
- "Try removing the import, or "
- "moving the imported file inside the 'lib' directory.");
-
- /**
- * It is a bad practice for a source file ouside a package "lib" directory
- * hierarchy to traverse into that directory hierarchy. For example, a source
- * file in the "web" directory should not contain a directive such as
- * `import '../lib/some.dart'` which references a file inside the lib
- * directory.
- */
- static const HintCode FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE =
- const HintCode(
- 'FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE',
- "A file outside the 'lib' directory shouldn't reference a file "
- "inside the 'lib' directory using a relative path.",
- "Try using a package: URI instead.");
-
- /**
- * It is a bad practice for a package import to reference anything outside the
- * given package, or more generally, it is bad practice for a package import
- * to contain a "..". For example, a source file should not contain a
- * directive such as `import 'package:foo/../some.dart'`.
- */
- static const HintCode PACKAGE_IMPORT_CONTAINS_DOT_DOT = const HintCode(
- 'PACKAGE_IMPORT_CONTAINS_DOT_DOT',
- "A package import shouldn't contain '..'.");
-
- /**
- * Initialize a newly created error code to have the given [name]. The message
- * associated with the error will be created from the given [message]
- * template. The correction associated with the error will be created from the
- * given [correction] template.
- */
- const HintCode(String name, String message, [String correction])
- : super(name, message, correction);
-
- @override
- ErrorSeverity get errorSeverity => ErrorType.HINT.severity;
-
- @override
- ErrorType get type => ErrorType.HINT;
-}
-
-/**
- * The error codes used for errors in HTML files. The convention for this
- * class is for the name of the error code to indicate the problem that caused
- * the error to be generated and for the error message to explain what is wrong
- * and, when appropriate, how the problem can be corrected.
- */
-class HtmlErrorCode extends ErrorCode {
- /**
- * An error code indicating that there is a syntactic error in the file.
- *
- * Parameters:
- * 0: the error message from the parse error
- */
- static const HtmlErrorCode PARSE_ERROR =
- const HtmlErrorCode('PARSE_ERROR', '{0}');
-
- /**
- * Initialize a newly created error code to have the given [name]. The message
- * associated with the error will be created from the given [message]
- * template. The correction associated with the error will be created from the
- * given [correction] template.
- */
- const HtmlErrorCode(String name, String message, [String correction])
- : super(name, message, correction);
-
- @override
- ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
-
- @override
- ErrorType get type => ErrorType.COMPILE_TIME_ERROR;
-}
-
-/**
- * The error codes used for warnings in HTML files. The convention for this
- * class is for the name of the error code to indicate the problem that caused
- * the error to be generated and for the error message to explain what is wrong
- * and, when appropriate, how the problem can be corrected.
- */
-class HtmlWarningCode extends ErrorCode {
- /**
- * An error code indicating that the value of the 'src' attribute of a Dart
- * script tag is not a valid URI.
- *
- * Parameters:
- * 0: the URI that is invalid
- */
- static const HtmlWarningCode INVALID_URI =
- const HtmlWarningCode('INVALID_URI', "Invalid URI syntax: '{0}'.");
-
- /**
- * An error code indicating that the value of the 'src' attribute of a Dart
- * script tag references a file that does not exist.
- *
- * Parameters:
- * 0: the URI pointing to a non-existent file
- */
- static const HtmlWarningCode URI_DOES_NOT_EXIST = const HtmlWarningCode(
- 'URI_DOES_NOT_EXIST', "Target of URI doesn't exist: '{0}'.");
-
- /**
- * Initialize a newly created error code to have the given [name]. The message
- * associated with the error will be created from the given [message]
- * template. The correction associated with the error will be created from the
- * given [correction] template.
- */
- const HtmlWarningCode(String name, String message, [String correction])
- : super(name, message, correction);
-
- @override
- ErrorSeverity get errorSeverity => ErrorSeverity.WARNING;
-
- @override
- ErrorType get type => ErrorType.STATIC_WARNING;
-}
-
-/**
- * Defines style and best practice recommendations.
- *
- * Unlike [HintCode]s, which are akin to traditional static warnings from a
- * compiler, lint recommendations focus on matters of style and practices that
- * might aggregated to define a project's style guide.
- */
-class LintCode extends ErrorCode {
- const LintCode(String name, String message, [String correction])
- : super(name, message, correction);
-
- @override
- ErrorSeverity get errorSeverity => ErrorSeverity.INFO;
-
- @override
- ErrorType get type => ErrorType.LINT;
-}
-
-/**
* The error codes used for static type warnings. The convention for this class
* is for the name of the error code to indicate the problem that caused the
* error to be generated and for the error message to explain what is wrong and,
@@ -5610,41 +4852,3 @@
@override
ErrorSeverity get errorSeverity => type.severity;
}
-
-/**
- * The error code indicating a marker in code for work that needs to be finished
- * or revisited.
- */
-class TodoCode extends ErrorCode {
- /**
- * The single enum of TodoCode.
- */
- static const TodoCode TODO = const TodoCode('TODO');
-
- /**
- * This matches the two common Dart task styles
- *
- * * TODO:
- * * TODO(username):
- *
- * As well as
- * * TODO
- *
- * But not
- * * todo
- * * TODOS
- */
- static RegExp TODO_REGEX =
- new RegExp("([\\s/\\*])((TODO[^\\w\\d][^\\r\\n]*)|(TODO:?\$))");
-
- /**
- * Initialize a newly created error code to have the given [name].
- */
- const TodoCode(String name) : super(name, "{0}");
-
- @override
- ErrorSeverity get errorSeverity => ErrorSeverity.INFO;
-
- @override
- ErrorType get type => ErrorType.TODO;
-}
diff --git a/pkg/analyzer/lib/src/generated/declaration_resolver.dart b/pkg/analyzer/lib/src/generated/declaration_resolver.dart
index a6b8a13..4d24b8b 100644
--- a/pkg/analyzer/lib/src/generated/declaration_resolver.dart
+++ b/pkg/analyzer/lib/src/generated/declaration_resolver.dart
@@ -65,14 +65,7 @@
@override
Object visitCatchClause(CatchClause node) {
- SimpleIdentifier exceptionParameter = node.exceptionParameter;
- if (exceptionParameter != null) {
- _match(exceptionParameter, _walker.getVariable());
- SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
- if (stackTraceParameter != null) {
- _match(stackTraceParameter, _walker.getVariable());
- }
- }
+ _walker.elementBuilder.buildCatchVariableElements(node);
return super.visitCatchClause(node);
}
@@ -98,8 +91,9 @@
@override
Object visitConstructorDeclaration(ConstructorDeclaration node) {
- ConstructorElement element = _match(node.name, _walker.getConstructor());
- _walk(new ElementWalker.forExecutable(element), () {
+ ConstructorElement element = _match(node.name, _walker.getConstructor(),
+ offset: node.name?.offset ?? node.returnType.offset);
+ _walk(new ElementWalker.forExecutable(element, _enclosingUnit), () {
node.element = element;
super.visitConstructorDeclaration(node);
});
@@ -109,9 +103,8 @@
@override
Object visitDeclaredIdentifier(DeclaredIdentifier node) {
- VariableElement element = _match(node.identifier, _walker.getVariable());
- super.visitDeclaredIdentifier(node);
- _resolveMetadata(node, node.metadata, element);
+ // Declared identifiers can only occur inside executable elements.
+ _walker.elementBuilder.visitDeclaredIdentifier(node);
return null;
}
@@ -121,12 +114,14 @@
_match(node.parameter.identifier, _walker.getParameter());
Expression defaultValue = node.defaultValue;
if (defaultValue != null) {
- _walk(new ElementWalker.forExecutable(element.initializer), () {
+ _walk(
+ new ElementWalker.forExecutable(element.initializer, _enclosingUnit),
+ () {
defaultValue.accept(this);
});
}
_walk(new ElementWalker.forParameter(element), () {
- super.visitDefaultFormalParameter(node);
+ node.parameter.accept(this);
});
_resolveMetadata(node, node.metadata, element);
return null;
@@ -194,7 +189,7 @@
}
}
node.functionExpression.element = element;
- _walk(new ElementWalker.forExecutable(element), () {
+ _walk(new ElementWalker.forExecutable(element, _enclosingUnit), () {
super.visitFunctionDeclaration(node);
});
_resolveMetadata(node, node.metadata, element);
@@ -205,8 +200,9 @@
Object visitFunctionExpression(FunctionExpression node) {
if (node.parent is! FunctionDeclaration) {
FunctionElement element = _walker.getFunction();
+ _matchOffset(element, node.offset);
node.element = element;
- _walk(new ElementWalker.forExecutable(element), () {
+ _walk(new ElementWalker.forExecutable(element, _enclosingUnit), () {
super.visitFunctionExpression(node);
});
return null;
@@ -250,9 +246,9 @@
@override
Object visitLabeledStatement(LabeledStatement node) {
- for (Label label in node.labels) {
- _match(label.label, _walker.getLabel());
- }
+ bool onSwitchStatement = node.statement is SwitchStatement;
+ _walker.elementBuilder
+ .buildLabelElements(node.labels, onSwitchStatement, false);
return super.visitLabeledStatement(node);
}
@@ -287,7 +283,7 @@
elementName: nameOfMethod + '=');
}
}
- _walk(new ElementWalker.forExecutable(element), () {
+ _walk(new ElementWalker.forExecutable(element, _enclosingUnit), () {
super.visitMethodDeclaration(node);
});
_resolveMetadata(node, node.metadata, element);
@@ -325,17 +321,13 @@
@override
Object visitSwitchCase(SwitchCase node) {
- for (Label label in node.labels) {
- _match(label.label, _walker.getLabel());
- }
+ _walker.elementBuilder.buildLabelElements(node.labels, false, true);
return super.visitSwitchCase(node);
}
@override
Object visitSwitchDefault(SwitchDefault node) {
- for (Label label in node.labels) {
- _match(label.label, _walker.getLabel());
- }
+ _walker.elementBuilder.buildLabelElements(node.labels, false, true);
return super.visitSwitchDefault(node);
}
@@ -359,7 +351,9 @@
VariableElement element = _match(node.name, _walker.getVariable());
Expression initializer = node.initializer;
if (initializer != null) {
- _walk(new ElementWalker.forExecutable(element.initializer), () {
+ _walk(
+ new ElementWalker.forExecutable(element.initializer, _enclosingUnit),
+ () {
super.visitVariableDeclaration(node);
});
return null;
@@ -370,12 +364,16 @@
@override
Object visitVariableDeclarationList(VariableDeclarationList node) {
- super.visitVariableDeclarationList(node);
- if (node.parent is! FieldDeclaration &&
- node.parent is! TopLevelVariableDeclaration) {
- _resolveMetadata(node, node.metadata, node.variables[0].element);
+ if (_walker.elementBuilder != null) {
+ return _walker.elementBuilder.visitVariableDeclarationList(node);
+ } else {
+ super.visitVariableDeclarationList(node);
+ if (node.parent is! FieldDeclaration &&
+ node.parent is! TopLevelVariableDeclaration) {
+ _resolveMetadata(node, node.metadata, node.variables[0].element);
+ }
+ return null;
}
- return null;
}
/**
@@ -390,16 +388,26 @@
*/
Element/*=E*/ _match/*<E extends Element>*/(
SimpleIdentifier identifier, Element/*=E*/ element,
- {String elementName}) {
+ {String elementName, int offset}) {
elementName ??= identifier?.name ?? '';
+ offset ??= identifier.offset;
if (element.name != elementName) {
throw new StateError(
'Expected an element matching `$elementName`, got `${element.name}`');
}
identifier?.staticElement = element;
+ _matchOffset(element, offset);
return element;
}
+ void _matchOffset(Element element, int offset) {
+ if (element.nameOffset != 0 && element.nameOffset != offset) {
+ throw new StateError('Element offset mismatch');
+ } else {
+ (element as ElementImpl).nameOffset = offset;
+ }
+ }
+
/**
* Associate each of the annotation [nodes] with the corresponding
* [ElementAnnotation] in [annotations]. If there is a problem, report it
@@ -461,6 +469,19 @@
*/
final Element element;
+ /**
+ * If [element] is an executable element, an element builder which is
+ * accumulating the executable element's local variables and labels.
+ * Otherwise `null`.
+ */
+ LocalElementBuilder elementBuilder;
+
+ /**
+ * If [element] is an executable element, the element holder associated with
+ * [elementBuilder]. Otherwise `null`.
+ */
+ ElementHolder _elementHolder;
+
List<PropertyAccessorElement> _accessors;
int _accessorIndex = 0;
List<ClassElement> _classes;
@@ -471,8 +492,6 @@
int _enumIndex = 0;
List<ExecutableElement> _functions;
int _functionIndex = 0;
- List<LabelElement> _labels;
- int _labelIndex = 0;
List<ParameterElement> _parameters;
int _parameterIndex = 0;
List<FunctionTypeAliasElement> _typedefs;
@@ -514,13 +533,9 @@
* Creates an [ElementWalker] which walks the child elements of a compilation
* unit element.
*/
- ElementWalker.forExecutable(ExecutableElement element)
- : element = element,
- _functions = element.functions,
- _labels = element.labels,
- _parameters = element.parameters,
- _typeParameters = element.typeParameters,
- _variables = element.localVariables;
+ ElementWalker.forExecutable(
+ ExecutableElement element, CompilationUnitElement compilationUnit)
+ : this._forExecutable(element, compilationUnit, new ElementHolder());
/**
* Creates an [ElementWalker] which walks the child elements of a parameter
@@ -540,6 +555,16 @@
_parameters = element.parameters,
_typeParameters = element.typeParameters;
+ ElementWalker._forExecutable(ExecutableElement element,
+ CompilationUnitElement compilationUnit, ElementHolder elementHolder)
+ : element = element,
+ elementBuilder =
+ new LocalElementBuilder(elementHolder, compilationUnit),
+ _elementHolder = elementHolder,
+ _functions = element.functions,
+ _parameters = element.parameters,
+ _typeParameters = element.typeParameters;
+
/**
* Returns the next non-synthetic child of [element] which is an accessor;
* throws an [IndexError] if there are no more.
@@ -572,12 +597,6 @@
ExecutableElement getFunction() => _functions[_functionIndex++];
/**
- * Returns the next non-synthetic child of [element] which is a label; throws
- * an [IndexError] if there are no more.
- */
- LabelElement getLabel() => _labels[_labelIndex++];
-
- /**
* Returns the next non-synthetic child of [element] which is a parameter;
* throws an [IndexError] if there are no more.
*/
@@ -620,11 +639,15 @@
check(_constructors, _constructorIndex);
check(_enums, _enumIndex);
check(_functions, _functionIndex);
- check(_labels, _labelIndex);
check(_parameters, _parameterIndex);
check(_typedefs, _typedefIndex);
check(_typeParameters, _typeParameterIndex);
check(_variables, _variableIndex);
+ Element element = this.element;
+ if (element is ExecutableElementImpl) {
+ element.labels = _elementHolder.labels;
+ element.localVariables = _elementHolder.localVariables;
+ }
}
static bool _isNotSynthetic(Element e) => !e.isSynthetic;
diff --git a/pkg/analyzer/lib/src/generated/java_core.dart b/pkg/analyzer/lib/src/generated/java_core.dart
index edaccce..994f553 100644
--- a/pkg/analyzer/lib/src/generated/java_core.dart
+++ b/pkg/analyzer/lib/src/generated/java_core.dart
@@ -138,6 +138,7 @@
String toString() => name;
}
+@deprecated
class PrintStringWriter extends PrintWriter {
final StringBuffer _sb = new StringBuffer();
diff --git a/pkg/analyzer/lib/src/generated/parser.dart b/pkg/analyzer/lib/src/generated/parser.dart
index 7e91310..d9e8d6e 100644
--- a/pkg/analyzer/lib/src/generated/parser.dart
+++ b/pkg/analyzer/lib/src/generated/parser.dart
@@ -780,6 +780,13 @@
}
Token operator = getAndAdvance();
return new PropertyAccess(prefix, operator, parseSimpleIdentifier());
+ } else if (type == TokenType.INDEX) {
+ _splitIndex();
+ Token leftBracket = getAndAdvance();
+ Expression index = parseSimpleIdentifier();
+ Token rightBracket = getAndAdvance();
+ return new IndexExpression.forTarget(
+ prefix, leftBracket, index, rightBracket);
} else {
if (!optional) {
// Report the missing selector.
@@ -3510,19 +3517,9 @@
*/
ListLiteral parseListLiteral(Token modifier, TypeArgumentList typeArguments) {
if (_matches(TokenType.INDEX)) {
- // Split the token into two separate tokens.
- BeginToken leftBracket = _createToken(
- _currentToken, TokenType.OPEN_SQUARE_BRACKET,
- isBegin: true);
- Token rightBracket =
- new Token(TokenType.CLOSE_SQUARE_BRACKET, _currentToken.offset + 1);
- leftBracket.endToken = rightBracket;
- rightBracket.setNext(_currentToken.next);
- leftBracket.setNext(rightBracket);
- _currentToken.previous.setNext(leftBracket);
- _currentToken = _currentToken.next;
+ _splitIndex();
return new ListLiteral(
- modifier, typeArguments, leftBracket, null, rightBracket);
+ modifier, typeArguments, getAndAdvance(), null, getAndAdvance());
}
Token leftBracket = getAndAdvance();
if (_matches(TokenType.CLOSE_SQUARE_BRACKET)) {
@@ -4119,7 +4116,8 @@
type == TokenType.PERIOD ||
type == TokenType.QUESTION_PERIOD ||
type == TokenType.OPEN_PAREN ||
- (parseGenericMethods && type == TokenType.LT)) {
+ (parseGenericMethods && type == TokenType.LT) ||
+ type == TokenType.INDEX) {
do {
if (_isLikelyArgumentList()) {
TypeArgumentList typeArguments = _parseOptionalTypeArguments();
@@ -4143,7 +4141,8 @@
} while (type == TokenType.OPEN_SQUARE_BRACKET ||
type == TokenType.PERIOD ||
type == TokenType.QUESTION_PERIOD ||
- type == TokenType.OPEN_PAREN);
+ type == TokenType.OPEN_PAREN ||
+ type == TokenType.INDEX);
return operand;
}
if (!_currentToken.type.isIncrementOperator) {
@@ -6252,7 +6251,8 @@
parseFunctionBody(true, ParserErrorCode.MISSING_FUNCTION_BODY, false);
if (constKeyword != null &&
factoryKeyword != null &&
- externalKeyword == null) {
+ externalKeyword == null &&
+ body is! NativeFunctionBody) {
_reportErrorForToken(ParserErrorCode.CONST_FACTORY, factoryKeyword);
} else if (body is EmptyFunctionBody) {
if (factoryKeyword != null &&
@@ -6262,7 +6262,7 @@
ParserErrorCode.FACTORY_WITHOUT_BODY, factoryKeyword);
}
} else {
- if (constKeyword != null) {
+ if (constKeyword != null && body is! NativeFunctionBody) {
_reportErrorForNode(
ParserErrorCode.CONST_CONSTRUCTOR_WITH_BODY, body);
} else if (externalKeyword != null) {
@@ -7584,6 +7584,24 @@
}
/**
+ * Assuming that the current token is an index token ('[]'), split it into two
+ * tokens ('[' and ']'), leaving the left bracket as the current token.
+ */
+ void _splitIndex() {
+ // Split the token into two separate tokens.
+ BeginToken leftBracket = _createToken(
+ _currentToken, TokenType.OPEN_SQUARE_BRACKET,
+ isBegin: true);
+ Token rightBracket =
+ new Token(TokenType.CLOSE_SQUARE_BRACKET, _currentToken.offset + 1);
+ leftBracket.endToken = rightBracket;
+ rightBracket.setNext(_currentToken.next);
+ leftBracket.setNext(rightBracket);
+ _currentToken.previous.setNext(leftBracket);
+ _currentToken = leftBracket;
+ }
+
+ /**
* Return `true` if the given [token] has the given [type].
*/
bool _tokenMatches(Token token, TokenType type) => token.type == type;
diff --git a/pkg/analyzer/lib/src/generated/type_system.dart b/pkg/analyzer/lib/src/generated/type_system.dart
index 2462145..c8c1fe6 100644
--- a/pkg/analyzer/lib/src/generated/type_system.dart
+++ b/pkg/analyzer/lib/src/generated/type_system.dart
@@ -1595,7 +1595,7 @@
//
// This will typically lead to top with the current rules, but it will
// work with `bottom` or if we remove Future flattening.
- var f = upperBound as FutureUnionType;
+ var f = lowerBound as FutureUnionType;
lowerBound = _typeSystem.getLeastUpperBound(
_typeProvider, f.futureOfType, f.type);
}
diff --git a/pkg/analyzer/lib/src/html/error/html_codes.dart b/pkg/analyzer/lib/src/html/error/html_codes.dart
new file mode 100644
index 0000000..1af2fcf
--- /dev/null
+++ b/pkg/analyzer/lib/src/html/error/html_codes.dart
@@ -0,0 +1,82 @@
+// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library analyzer.src.html.error.lint_codes;
+
+import 'package:analyzer/error/error.dart';
+
+/**
+ * The error codes used for errors in HTML files. The convention for this
+ * class is for the name of the error code to indicate the problem that caused
+ * the error to be generated and for the error message to explain what is wrong
+ * and, when appropriate, how the problem can be corrected.
+ */
+class HtmlErrorCode extends ErrorCode {
+ /**
+ * An error code indicating that there is a syntactic error in the file.
+ *
+ * Parameters:
+ * 0: the error message from the parse error
+ */
+ static const HtmlErrorCode PARSE_ERROR =
+ const HtmlErrorCode('PARSE_ERROR', '{0}');
+
+ /**
+ * Initialize a newly created error code to have the given [name]. The message
+ * associated with the error will be created from the given [message]
+ * template. The correction associated with the error will be created from the
+ * given [correction] template.
+ */
+ const HtmlErrorCode(String name, String message, [String correction])
+ : super(name, message, correction);
+
+ @override
+ ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
+
+ @override
+ ErrorType get type => ErrorType.COMPILE_TIME_ERROR;
+}
+
+/**
+ * The error codes used for warnings in HTML files. The convention for this
+ * class is for the name of the error code to indicate the problem that caused
+ * the error to be generated and for the error message to explain what is wrong
+ * and, when appropriate, how the problem can be corrected.
+ */
+class HtmlWarningCode extends ErrorCode {
+ /**
+ * An error code indicating that the value of the 'src' attribute of a Dart
+ * script tag is not a valid URI.
+ *
+ * Parameters:
+ * 0: the URI that is invalid
+ */
+ static const HtmlWarningCode INVALID_URI =
+ const HtmlWarningCode('INVALID_URI', "Invalid URI syntax: '{0}'.");
+
+ /**
+ * An error code indicating that the value of the 'src' attribute of a Dart
+ * script tag references a file that does not exist.
+ *
+ * Parameters:
+ * 0: the URI pointing to a non-existent file
+ */
+ static const HtmlWarningCode URI_DOES_NOT_EXIST = const HtmlWarningCode(
+ 'URI_DOES_NOT_EXIST', "Target of URI doesn't exist: '{0}'.");
+
+ /**
+ * Initialize a newly created error code to have the given [name]. The message
+ * associated with the error will be created from the given [message]
+ * template. The correction associated with the error will be created from the
+ * given [correction] template.
+ */
+ const HtmlWarningCode(String name, String message, [String correction])
+ : super(name, message, correction);
+
+ @override
+ ErrorSeverity get errorSeverity => ErrorSeverity.WARNING;
+
+ @override
+ ErrorType get type => ErrorType.STATIC_WARNING;
+}
diff --git a/pkg/analyzer/lib/src/summary/format.dart b/pkg/analyzer/lib/src/summary/format.dart
index 6d4ecc8..d24aa70 100644
--- a/pkg/analyzer/lib/src/summary/format.dart
+++ b/pkg/analyzer/lib/src/summary/format.dart
@@ -6970,6 +6970,8 @@
_nameOffset = null;
_parameters?.forEach((b) => b.flushInformative());
_type?.flushInformative();
+ _visibleLength = null;
+ _visibleOffset = null;
}
/**
@@ -6999,8 +7001,6 @@
x?.collectApiSignature(signature);
}
}
- signature.addInt(this._visibleLength ?? 0);
- signature.addInt(this._visibleOffset ?? 0);
signature.addBool(this._initializer != null);
this._initializer?.collectApiSignature(signature);
signature.addInt(this._inheritsCovariantSlot ?? 0);
@@ -9245,6 +9245,8 @@
_initializer?.flushInformative();
_nameOffset = null;
_type?.flushInformative();
+ _visibleLength = null;
+ _visibleOffset = null;
}
/**
@@ -9267,8 +9269,6 @@
}
}
signature.addInt(this._inferredTypeSlot ?? 0);
- signature.addInt(this._visibleLength ?? 0);
- signature.addInt(this._visibleOffset ?? 0);
signature.addBool(this._initializer != null);
this._initializer?.collectApiSignature(signature);
}
diff --git a/pkg/analyzer/lib/src/summary/idl.dart b/pkg/analyzer/lib/src/summary/idl.dart
index 07a9461..61f62a8 100644
--- a/pkg/analyzer/lib/src/summary/idl.dart
+++ b/pkg/analyzer/lib/src/summary/idl.dart
@@ -2337,12 +2337,14 @@
/**
* The length of the visible range.
*/
+ @informative
@Id(10)
int get visibleLength;
/**
* The beginning of the visible range.
*/
+ @informative
@Id(11)
int get visibleOffset;
}
@@ -2818,12 +2820,14 @@
/**
* If a local variable, the length of the visible range; zero otherwise.
*/
+ @informative
@Id(11)
int get visibleLength;
/**
* If a local variable, the beginning of the visible range; zero otherwise.
*/
+ @informative
@Id(12)
int get visibleOffset;
}
diff --git a/pkg/analyzer/pubspec.yaml b/pkg/analyzer/pubspec.yaml
index a17b516..0c265d5 100644
--- a/pkg/analyzer/pubspec.yaml
+++ b/pkg/analyzer/pubspec.yaml
@@ -1,5 +1,5 @@
name: analyzer
-version: 0.29.0
+version: 0.30.0-alpha.0
author: Dart Team <misc@dartlang.org>
description: Static analyzer for Dart.
homepage: https://github.com/dart-lang/sdk/tree/master/pkg/analyzer
diff --git a/pkg/analyzer/test/generated/declaration_resolver_test.dart b/pkg/analyzer/test/generated/declaration_resolver_test.dart
index 9226efe..74232ac 100644
--- a/pkg/analyzer/test/generated/declaration_resolver_test.dart
+++ b/pkg/analyzer/test/generated/declaration_resolver_test.dart
@@ -45,13 +45,16 @@
CompilationUnit unit;
CompilationUnit unit2;
- void checkMetadata(String search) {
+ void checkMetadata(String search, {bool expectDifferent: false}) {
NodeList<Annotation> metadata = _findMetadata(unit, search);
NodeList<Annotation> metadata2 = _findMetadata(unit2, search);
expect(metadata, isNotEmpty);
for (int i = 0; i < metadata.length; i++) {
- expect(
- metadata2[i].elementAnnotation, same(metadata[i].elementAnnotation));
+ Matcher expectation = same(metadata[i].elementAnnotation);
+ if (expectDifferent) {
+ expectation = isNot(expectation);
+ }
+ expect(metadata2[i].elementAnnotation, expectation);
}
}
@@ -83,7 +86,7 @@
void test_metadata_declaredIdentifier() {
setupCode('f(x, y) { for (@a var x in y) {} }');
- checkMetadata('var');
+ checkMetadata('var', expectDifferent: true);
}
void test_metadata_enumDeclaration() {
@@ -175,7 +178,7 @@
void test_metadata_localVariableDeclaration() {
setupCode('f() { @a int x; }');
- checkMetadata('x');
+ checkMetadata('x', expectDifferent: true);
}
void test_metadata_methodDeclaration_getter() {
@@ -258,6 +261,70 @@
super.setUp();
}
+ void test_closure_inside_catch_block() {
+ String code = '''
+f() {
+ try {
+ } catch (e) {
+ return () => null;
+ }
+}
+''';
+ CompilationUnit unit = resolveSource(code);
+ // re-resolve
+ _cloneResolveUnit(unit);
+ // no other validations than built into DeclarationResolver
+ }
+
+ void test_closure_inside_labeled_statement() {
+ String code = '''
+f(b) {
+ foo: while (true) {
+ if (b) {
+ break foo;
+ }
+ return () => null;
+ }
+}
+''';
+ CompilationUnit unit = resolveSource(code);
+ // re-resolve
+ _cloneResolveUnit(unit);
+ // no other validations than built into DeclarationResolver
+ }
+
+ void test_closure_inside_switch_case() {
+ String code = '''
+void f(k, m) {
+ switch (k) {
+ case 0:
+ m.forEach((key, value) {});
+ break;
+ }
+}
+''';
+ CompilationUnit unit = resolveSource(code);
+ // re-resolve
+ _cloneResolveUnit(unit);
+ // no other validations than built into DeclarationResolver
+ }
+
+ void test_closure_inside_switch_default() {
+ String code = '''
+void f(k, m) {
+ switch (k) {
+ default:
+ m.forEach((key, value) {});
+ break;
+ }
+}
+''';
+ CompilationUnit unit = resolveSource(code);
+ // re-resolve
+ _cloneResolveUnit(unit);
+ // no other validations than built into DeclarationResolver
+ }
+
void test_enumConstant_partiallyResolved() {
String code = r'''
enum Fruit {apple, pear}
diff --git a/pkg/analyzer/test/generated/non_error_resolver_test.dart b/pkg/analyzer/test/generated/non_error_resolver_test.dart
index fd4487f..f172ec6 100644
--- a/pkg/analyzer/test/generated/non_error_resolver_test.dart
+++ b/pkg/analyzer/test/generated/non_error_resolver_test.dart
@@ -3727,6 +3727,18 @@
// Cannot verify the AST because the import's URI cannot be resolved.
}
+ void test_nativeConstConstructor() {
+ Source source = addSource(r'''
+import 'dart-ext:x';
+class Foo {
+ const Foo() native 'Foo_Foo';
+ const factory Foo.foo() native 'Foo_Foo_foo';
+}''');
+ computeLibrarySourceErrors(source);
+ assertNoErrors(source);
+ // Cannot verify the AST because the import's URI cannot be resolved.
+ }
+
void test_newWithAbstractClass_factory() {
Source source = addSource(r'''
abstract class A {
diff --git a/pkg/analyzer/test/generated/parser_test.dart b/pkg/analyzer/test/generated/parser_test.dart
index 61d6577..2465b13 100644
--- a/pkg/analyzer/test/generated/parser_test.dart
+++ b/pkg/analyzer/test/generated/parser_test.dart
@@ -3123,6 +3123,14 @@
BinaryExpression, expression.leftOperand);
}
+ void test_assignableSelector() {
+ IndexExpression expression =
+ parseExpression("a.b[]", [ParserErrorCode.MISSING_IDENTIFIER]);
+ Expression index = expression.index;
+ expect(index, new isInstanceOf<SimpleIdentifier>());
+ expect(index.isSynthetic, isTrue);
+ }
+
void test_assignmentExpression_missing_compound1() {
AssignmentExpression expression =
parseExpression("= y = 0", [ParserErrorCode.MISSING_IDENTIFIER]);
diff --git a/pkg/analyzer/test/src/command_line/arguments_test.dart b/pkg/analyzer/test/src/command_line/arguments_test.dart
new file mode 100644
index 0000000..3e1e940
--- /dev/null
+++ b/pkg/analyzer/test/src/command_line/arguments_test.dart
@@ -0,0 +1,208 @@
+// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library analyzer.test.src.context.context_builder_test;
+
+import 'package:analyzer/file_system/memory_file_system.dart';
+import 'package:analyzer/src/command_line/arguments.dart';
+import 'package:analyzer/src/context/builder.dart';
+import 'package:analyzer/src/dart/sdk/sdk.dart';
+import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/sdk.dart';
+import 'package:args/args.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(ArgumentsTest);
+ });
+}
+
+@reflectiveTest
+class ArgumentsTest {
+ void test_createContextBuilderOptions_all() {
+ String dartSdkSummaryPath = 'a';
+ String defaultAnalysisOptionsFilePath = 'b';
+ String defaultPackageFilePath = 'c';
+ String defaultPackagesDirectoryPath = 'd';
+ MemoryResourceProvider provider = new MemoryResourceProvider();
+ ArgParser parser = new ArgParser();
+ defineAnalysisArguments(parser);
+ List<String> args = [
+ '--dart-sdk-summary=$dartSdkSummaryPath',
+ '-Dfoo=1',
+ '-Dbar=2',
+ '--enable-strict-call-checks',
+ '--initializing-formal-access',
+ '--no-implicit-casts',
+ '--no-implicit-dynamic',
+ '--options=$defaultAnalysisOptionsFilePath',
+ '--packages=$defaultPackageFilePath',
+ '--package-root=$defaultPackagesDirectoryPath',
+ '--strong',
+ '--supermixin',
+ ];
+ ArgResults result = parse(provider, parser, args);
+ ContextBuilderOptions options = createContextBuilderOptions(result);
+ expect(options, isNotNull);
+ expect(options.dartSdkSummaryPath, dartSdkSummaryPath);
+ Map<String, String> declaredVariables = options.declaredVariables;
+ expect(declaredVariables, hasLength(2));
+ expect(declaredVariables['foo'], '1');
+ expect(declaredVariables['bar'], '2');
+ expect(
+ options.defaultAnalysisOptionsFilePath, defaultAnalysisOptionsFilePath);
+ expect(options.defaultPackageFilePath, defaultPackageFilePath);
+ expect(options.defaultPackagesDirectoryPath, defaultPackagesDirectoryPath);
+ AnalysisOptionsImpl defaultOptions = options.defaultOptions;
+ expect(defaultOptions, isNotNull);
+ expect(defaultOptions.enableInitializingFormalAccess, true);
+ expect(defaultOptions.enableStrictCallChecks, true);
+ expect(defaultOptions.strongMode, true);
+ expect(defaultOptions.implicitCasts, false);
+ expect(defaultOptions.implicitDynamic, false);
+ expect(options.pubSummaryManager, isNull);
+ }
+
+ void test_createContextBuilderOptions_none() {
+ MemoryResourceProvider provider = new MemoryResourceProvider();
+ ArgParser parser = new ArgParser();
+ defineAnalysisArguments(parser);
+ List<String> args = [];
+ ArgResults result = parse(provider, parser, args);
+ ContextBuilderOptions options = createContextBuilderOptions(result);
+ expect(options, isNotNull);
+ expect(options.dartSdkSummaryPath, isNull);
+ expect(options.declaredVariables, isEmpty);
+ expect(options.defaultAnalysisOptionsFilePath, isNull);
+ expect(options.defaultPackageFilePath, isNull);
+ expect(options.defaultPackagesDirectoryPath, isNull);
+ AnalysisOptionsImpl defaultOptions = options.defaultOptions;
+ expect(defaultOptions, isNotNull);
+ expect(defaultOptions.enableInitializingFormalAccess, false);
+ expect(defaultOptions.enableStrictCallChecks, false);
+ expect(defaultOptions.strongMode, false);
+ expect(defaultOptions.implicitCasts, true);
+ expect(defaultOptions.implicitDynamic, true);
+ expect(options.pubSummaryManager, isNull);
+ }
+
+ void test_createDartSdkManager_noPath_noSummaries() {
+ MemoryResourceProvider provider = new MemoryResourceProvider();
+ ArgParser parser = new ArgParser();
+ defineAnalysisArguments(parser);
+ List<String> args = [];
+ ArgResults result = parse(provider, parser, args);
+ DartSdkManager manager = createDartSdkManager(provider, false, result);
+ expect(manager, isNotNull);
+ expect(manager.defaultSdkDirectory,
+ FolderBasedDartSdk.defaultSdkDirectory(provider));
+ expect(manager.canUseSummaries, false);
+ }
+
+ void test_createDartSdkManager_noPath_summaries() {
+ MemoryResourceProvider provider = new MemoryResourceProvider();
+ ArgParser parser = new ArgParser();
+ defineAnalysisArguments(parser);
+ List<String> args = [];
+ ArgResults result = parse(provider, parser, args);
+ DartSdkManager manager = createDartSdkManager(provider, true, result);
+ expect(manager, isNotNull);
+ expect(manager.defaultSdkDirectory,
+ FolderBasedDartSdk.defaultSdkDirectory(provider));
+ expect(manager.canUseSummaries, true);
+ }
+
+ void test_createDartSdkManager_path_noSummaries() {
+ MemoryResourceProvider provider = new MemoryResourceProvider();
+ ArgParser parser = new ArgParser();
+ defineAnalysisArguments(parser);
+ List<String> args = ['--dart-sdk=x'];
+ ArgResults result = parse(provider, parser, args);
+ DartSdkManager manager = createDartSdkManager(provider, false, result);
+ expect(manager, isNotNull);
+ expect(manager.defaultSdkDirectory, 'x');
+ expect(manager.canUseSummaries, false);
+ }
+
+ void test_createDartSdkManager_path_summaries() {
+ MemoryResourceProvider provider = new MemoryResourceProvider();
+ ArgParser parser = new ArgParser();
+ defineAnalysisArguments(parser);
+ List<String> args = ['--dart-sdk=y'];
+ ArgResults result = parse(provider, parser, args);
+ DartSdkManager manager = createDartSdkManager(provider, true, result);
+ expect(manager, isNotNull);
+ expect(manager.defaultSdkDirectory, 'y');
+ expect(manager.canUseSummaries, true);
+ }
+
+ void test_defineAnalysisArguments() {
+ ArgParser parser = new ArgParser();
+ defineAnalysisArguments(parser);
+ expect(parser.options, hasLength(12));
+ }
+
+ void test_filterUnknownArguments() {
+ List<String> args = ['--a', '--b', '--c', 'foo', 'bar'];
+ ArgParser parser = new ArgParser();
+ parser.addFlag('a');
+ parser.addFlag('c');
+ List<String> result = filterUnknownArguments(args, parser);
+ expect(result, orderedEquals(['--a', '--c', 'foo', 'bar']));
+ }
+
+ void test_parse_noReplacement_noIgnored() {
+ MemoryResourceProvider provider = new MemoryResourceProvider();
+ ArgParser parser = new ArgParser();
+ parser.addFlag('xx');
+ parser.addOption('yy');
+ List<String> args = ['--xx', '--yy=abc', 'foo', 'bar'];
+ ArgResults result = parse(provider, parser, args);
+ expect(result, isNotNull);
+ expect(result['xx'], true);
+ expect(result['yy'], 'abc');
+ expect(result.rest, orderedEquals(['foo', 'bar']));
+ }
+
+ void test_preprocessArgs_noReplacement() {
+ MemoryResourceProvider provider = new MemoryResourceProvider();
+ List<String> result = preprocessArgs(provider, ['--xx' '--yy' 'baz']);
+ expect(result, orderedEquals(['--xx' '--yy' 'baz']));
+ }
+
+ void test_preprocessArgs_replacement_exists() {
+ MemoryResourceProvider provider = new MemoryResourceProvider();
+ String filePath = provider.convertPath('/args.txt');
+ provider.newFile(
+ filePath,
+ '''
+-a
+--xx
+
+foo
+bar
+''');
+ List<String> result =
+ preprocessArgs(provider, ['--preserved', '@$filePath']);
+ expect(result, orderedEquals(['--preserved', '-a', '--xx', 'foo', 'bar']));
+ }
+
+ void test_preprocessArgs_replacement_nonexistent() {
+ MemoryResourceProvider provider = new MemoryResourceProvider();
+ String filePath = provider.convertPath('/args.txt');
+ List<String> args = ['ignored', '@$filePath'];
+ List<String> result = preprocessArgs(provider, args);
+ expect(result, orderedEquals(args));
+ }
+
+ void test_preprocessArgs_replacement_notLast() {
+ MemoryResourceProvider provider = new MemoryResourceProvider();
+ String filePath = provider.convertPath('/args.txt');
+ List<String> args = ['a', '@$filePath', 'b'];
+ List<String> result = preprocessArgs(provider, args);
+ expect(result, orderedEquals(args));
+ }
+}
diff --git a/pkg/analyzer/test/src/command_line/test_all.dart b/pkg/analyzer/test/src/command_line/test_all.dart
new file mode 100644
index 0000000..c3239f9
--- /dev/null
+++ b/pkg/analyzer/test/src/command_line/test_all.dart
@@ -0,0 +1,15 @@
+// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library analyzer.test.src.command_line.test_all;
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'arguments_test.dart' as arguments_test;
+
+main() {
+ defineReflectiveSuite(() {
+ arguments_test.main();
+ }, name: 'command_line');
+}
diff --git a/pkg/analyzer/test/src/context/builder_test.dart b/pkg/analyzer/test/src/context/builder_test.dart
index fe5031c..b05daa5 100644
--- a/pkg/analyzer/test/src/context/builder_test.dart
+++ b/pkg/analyzer/test/src/context/builder_test.dart
@@ -55,6 +55,11 @@
ContentCache contentCache;
/**
+ * The options passed to the context builder.
+ */
+ ContextBuilderOptions builderOptions = new ContextBuilderOptions();
+
+ /**
* The context builder to be used in the test.
*/
ContextBuilder builder;
@@ -83,7 +88,8 @@
};
''');
sdkManager = new DartSdkManager(defaultSdkPath, false);
- builder = new ContextBuilder(resourceProvider, sdkManager, contentCache);
+ builder = new ContextBuilder(resourceProvider, sdkManager, contentCache,
+ options: builderOptions);
}
void createFile(String path, String content) {
@@ -98,7 +104,8 @@
sdkManager =
new DartSdkManager(resourceProvider.convertPath('/sdk'), false);
contentCache = new ContentCache();
- builder = new ContextBuilder(resourceProvider, sdkManager, contentCache);
+ builder = new ContextBuilder(resourceProvider, sdkManager, contentCache,
+ options: builderOptions);
}
@failingTest
@@ -142,7 +149,7 @@
defaultOptions.enableStrictCallChecks =
!defaultOptions.enableStrictCallChecks;
defaultOptions.enableSuperMixins = !defaultOptions.enableSuperMixins;
- builder.defaultOptions = defaultOptions;
+ builderOptions.defaultOptions = defaultOptions;
AnalysisOptions options = builder.createDefaultOptions();
_expectEqualOptions(options, defaultOptions);
}
@@ -165,7 +172,7 @@
resourceProvider.newFolder(fooPath);
resourceProvider.newFolder(barPath);
- builder.defaultPackagesDirectoryPath = packageDirPath;
+ builderOptions.defaultPackagesDirectoryPath = packageDirPath;
Packages packages = builder.createPackageMap(projectPath);
expect(packages, isNotNull);
@@ -209,7 +216,7 @@
bar:$barUri
''');
- builder.defaultPackageFilePath = packageFilePath;
+ builderOptions.defaultPackageFilePath = packageFilePath;
Packages packages = builder.createPackageMap(projectPath);
expect(packages, isNotNull);
Map<String, Uri> map = packages.asMap();
@@ -410,7 +417,7 @@
void test_declareVariables_emptyMap() {
AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
Iterable<String> expected = context.declaredVariables.variableNames;
- builder.declaredVariables = <String, String>{};
+ builderOptions.declaredVariables = <String, String>{};
builder.declareVariables(context);
expect(context.declaredVariables.variableNames, unorderedEquals(expected));
@@ -422,7 +429,7 @@
expect(expected, isNot(contains('a')));
expect(expected, isNot(contains('b')));
expected.addAll(['a', 'b']);
- builder.declaredVariables = <String, String>{'a': 'a', 'b': 'b'};
+ builderOptions.declaredVariables = <String, String>{'a': 'a', 'b': 'b'};
builder.declareVariables(context);
expect(context.declaredVariables.variableNames, unorderedEquals(expected));
@@ -491,7 +498,7 @@
void test_getAnalysisOptions_default_noOverrides() {
AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
defaultOptions.enableGenericMethods = true;
- builder.defaultOptions = defaultOptions;
+ builderOptions.defaultOptions = defaultOptions;
AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
expected.enableGenericMethods = true;
String path = resourceProvider.convertPath('/some/directory/path');
@@ -513,7 +520,7 @@
void test_getAnalysisOptions_default_overrides() {
AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
defaultOptions.enableGenericMethods = true;
- builder.defaultOptions = defaultOptions;
+ builderOptions.defaultOptions = defaultOptions;
AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
expected.enableSuperMixins = true;
expected.enableGenericMethods = true;
@@ -611,7 +618,7 @@
String filePath = resourceProvider.convertPath('/options/analysis.yaml');
resourceProvider.newFile(filePath, '');
- builder.defaultAnalysisOptionsFilePath = filePath;
+ builderOptions.defaultAnalysisOptionsFilePath = filePath;
File result = builder.getOptionsFile(path);
expect(result, isNotNull);
expect(result.path, filePath);
diff --git a/pkg/analyzer/test/src/context/context_test.dart b/pkg/analyzer/test/src/context/context_test.dart
index 83de70d..7c6c668 100644
--- a/pkg/analyzer/test/src/context/context_test.dart
+++ b/pkg/analyzer/test/src/context/context_test.dart
@@ -2475,6 +2475,7 @@
}
void functionWithGenericFunctionTypedParam/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {}
+void functionWithClosureAsDefaultParam([x = () => null]) {}
''');
context.resolveCompilationUnit2(source, source);
LibraryElement firstElement = context.computeLibraryElement(source);
@@ -5256,7 +5257,11 @@
@override
void visitElement(Element element) {
Element previousElement = previousElements[element];
- if (!identical(previousElement, element)) {
+ bool expectIdentical = element is! LocalVariableElement;
+ bool ok = expectIdentical
+ ? identical(previousElement, element)
+ : previousElement == element;
+ if (!ok) {
if (overwrittenCount == 0) {
buffer.writeln();
}
diff --git a/pkg/analyzer/test/src/dart/ast/utilities_test.dart b/pkg/analyzer/test/src/dart/ast/utilities_test.dart
index 7b4d93a..3d4364f 100644
--- a/pkg/analyzer/test/src/dart/ast/utilities_test.dart
+++ b/pkg/analyzer/test/src/dart/ast/utilities_test.dart
@@ -28,6 +28,7 @@
defineReflectiveTests(NodeLocatorTest);
defineReflectiveTests(NodeLocator2Test);
defineReflectiveTests(ResolutionCopierTest);
+ // ignore: deprecated_member_use
defineReflectiveTests(ToSourceVisitorTest);
defineReflectiveTests(ToSourceVisitor2Test);
});
@@ -3344,6 +3345,7 @@
}
}
+@deprecated
@reflectiveTest
class ToSourceVisitorTest extends EngineTestCase {
void test_visitAdjacentStrings() {
diff --git a/pkg/analyzer/test/src/summary/resynthesize_common.dart b/pkg/analyzer/test/src/summary/resynthesize_common.dart
index 5f1f619..bf040c6 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_common.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_common.dart
@@ -1259,6 +1259,8 @@
} else if (modifier == Modifier.STATIC) {
if (element is ExecutableElement) {
return element.isStatic;
+ } else if (element is FieldElement) {
+ return element.isStatic;
}
return false;
} else if (modifier == Modifier.SYNTHETIC) {
diff --git a/pkg/analyzer/test/src/test_all.dart b/pkg/analyzer/test/src/test_all.dart
index 41743e2..8f727da 100644
--- a/pkg/analyzer/test/src/test_all.dart
+++ b/pkg/analyzer/test/src/test_all.dart
@@ -6,6 +6,7 @@
import 'package:test_reflective_loader/test_reflective_loader.dart';
+import 'command_line/test_all.dart' as command_line;
import 'context/test_all.dart' as context;
import 'dart/test_all.dart' as dart;
import 'plugin/plugin_config_test.dart' as plugin;
@@ -17,6 +18,7 @@
/// Utility for manually running all tests.
main() {
defineReflectiveSuite(() {
+ command_line.main();
context.main();
dart.main();
plugin.main();
diff --git a/pkg/analyzer/test/stress/for_git_repository.dart b/pkg/analyzer/test/stress/for_git_repository.dart
index 0fe14f3..2310581 100644
--- a/pkg/analyzer/test/stress/for_git_repository.dart
+++ b/pkg/analyzer/test/stress/for_git_repository.dart
@@ -246,9 +246,11 @@
FolderBasedDartSdk.defaultSdkDirectory(resourceProvider);
sdkManager = new DartSdkManager(sdkDirectory.path, false);
contentCache = new ContentCache();
- ContextBuilder builder =
- new ContextBuilder(resourceProvider, sdkManager, contentCache);
- builder.defaultOptions = new AnalysisOptionsImpl();
+ ContextBuilderOptions builderOptions = new ContextBuilderOptions();
+ builderOptions.defaultOptions = new AnalysisOptionsImpl();
+ ContextBuilder builder = new ContextBuilder(
+ resourceProvider, sdkManager, contentCache,
+ options: builderOptions);
expectedContext = builder.buildContext(folderPath);
actualContext = builder.buildContext(folderPath);
expectedContext.analysisOptions =
diff --git a/pkg/analyzer/tool/task_dependency_graph/generate.dart b/pkg/analyzer/tool/task_dependency_graph/generate.dart
index 9761e90..26745f6 100644
--- a/pkg/analyzer/tool/task_dependency_graph/generate.dart
+++ b/pkg/analyzer/tool/task_dependency_graph/generate.dart
@@ -154,17 +154,19 @@
DartSdk sdk = new FolderBasedDartSdk(resourceProvider,
FolderBasedDartSdk.defaultSdkDirectory(resourceProvider));
context = AnalysisEngine.instance.createAnalysisContext();
- ContextBuilder builder = new ContextBuilder(resourceProvider, null, null);
+ ContextBuilderOptions builderOptions = new ContextBuilderOptions();
if (Platform.packageRoot != null) {
- builder.defaultPackagesDirectoryPath =
- Uri.parse(Platform.packageRoot).toFilePath();
+ builderOptions.defaultPackagesDirectoryPath =
+ Uri.parse(Platform.packageRoot).toFilePath();
} else if (Platform.packageConfig != null) {
- builder.defaultPackageFilePath =
- Uri.parse(Platform.packageConfig).toFilePath();
+ builderOptions.defaultPackageFilePath =
+ Uri.parse(Platform.packageConfig).toFilePath();
} else {
// Let the context builder use the default algorithm for package
// resolution.
}
+ ContextBuilder builder = new ContextBuilder(resourceProvider, null, null,
+ options: builderOptions);
List<UriResolver> uriResolvers = [
new DartUriResolver(sdk),
new PackageMapUriResolver(resourceProvider,
diff --git a/pkg/analyzer_cli/lib/src/driver.dart b/pkg/analyzer_cli/lib/src/driver.dart
index d46d3f5..aef2211 100644
--- a/pkg/analyzer_cli/lib/src/driver.dart
+++ b/pkg/analyzer_cli/lib/src/driver.dart
@@ -373,8 +373,10 @@
UriResolver packageUriResolver;
if (options.packageRootPath != null) {
- ContextBuilder builder = new ContextBuilder(resourceProvider, null, null);
- builder.defaultPackagesDirectoryPath = options.packageRootPath;
+ ContextBuilderOptions builderOptions = new ContextBuilderOptions();
+ builderOptions.defaultPackagesDirectoryPath = options.packageRootPath;
+ ContextBuilder builder = new ContextBuilder(resourceProvider, null, null,
+ options: builderOptions);
packageUriResolver = new PackageMapUriResolver(resourceProvider,
builder.convertPackagesToMap(builder.createPackageMap('')));
} else if (options.packageConfigPath == null) {
diff --git a/pkg/compiler/lib/src/helpers/debug_collection.dart b/pkg/compiler/lib/src/helpers/debug_collection.dart
index 751b8c8..b20bf0c 100644
--- a/pkg/compiler/lib/src/helpers/debug_collection.dart
+++ b/pkg/compiler/lib/src/helpers/debug_collection.dart
@@ -261,7 +261,7 @@
Set<E> union(Set<E> other) => set.union(other);
- Set<E> difference(Set<E> other) => set.difference(other);
+ Set<E> difference(Set<Object> other) => set.difference(other);
void clear() => set.clear();
diff --git a/pkg/compiler/lib/src/helpers/expensive_set.dart b/pkg/compiler/lib/src/helpers/expensive_set.dart
index 2b34cfb..d4c6493 100644
--- a/pkg/compiler/lib/src/helpers/expensive_set.dart
+++ b/pkg/compiler/lib/src/helpers/expensive_set.dart
@@ -101,7 +101,7 @@
return _newSet()..addAll(this)..addAll(other);
}
- Set<E> difference(Set<E> other) {
+ Set<E> difference(Set<Object> other) {
Set<E> result = _newSet();
for (E element in this) {
if (!other.contains(element)) result.add(element);
diff --git a/pkg/compiler/lib/src/js_backend/backend.dart b/pkg/compiler/lib/src/js_backend/backend.dart
index 6ac1c15..5b843fe 100644
--- a/pkg/compiler/lib/src/js_backend/backend.dart
+++ b/pkg/compiler/lib/src/js_backend/backend.dart
@@ -72,7 +72,7 @@
import 'custom_elements_analysis.dart';
import 'enqueuer.dart';
import 'js_interop_analysis.dart' show JsInteropAnalysis;
-import 'kernel_task.dart';
+import '../kernel/task.dart';
import 'lookup_map_analysis.dart' show LookupMapAnalysis;
import 'namer.dart';
import 'native_data.dart' show NativeData;
@@ -476,6 +476,7 @@
List<CompilerTask> result = functionCompiler.tasks;
result.add(emitter);
result.add(patchResolverTask);
+ result.add(kernelTask);
return result;
}
@@ -629,7 +630,7 @@
jsInteropAnalysis = new JsInteropAnalysis(this);
noSuchMethodRegistry = new NoSuchMethodRegistry(this);
- kernelTask = new KernelTask(this);
+ kernelTask = new KernelTask(compiler);
constantCompilerTask = new JavaScriptConstantTask(compiler);
impactTransformer = new JavaScriptImpactTransformer(this);
patchResolverTask = new PatchResolverTask(compiler);
diff --git a/pkg/compiler/lib/src/js_emitter/runtime_type_generator.dart b/pkg/compiler/lib/src/js_emitter/runtime_type_generator.dart
index 170d16d..7cffc44 100644
--- a/pkg/compiler/lib/src/js_emitter/runtime_type_generator.dart
+++ b/pkg/compiler/lib/src/js_emitter/runtime_type_generator.dart
@@ -81,11 +81,13 @@
if (!method.isAbstract) {
ClosureClassMap closureData = compiler.closureToClassMapper
.getClosureToClassMapping(method.resolvedAst);
- ClosureFieldElement thisLocal =
- closureData.freeVariableMap[closureData.thisLocal];
- if (thisLocal != null) {
- jsAst.Name thisName = namer.instanceFieldPropertyName(thisLocal);
- thisAccess = js('this.#', thisName);
+ if (closureData != null) {
+ ClosureFieldElement thisLocal =
+ closureData.freeVariableMap[closureData.thisLocal];
+ if (thisLocal != null) {
+ jsAst.Name thisName = namer.instanceFieldPropertyName(thisLocal);
+ thisAccess = js('this.#', thisName);
+ }
}
}
diff --git a/pkg/compiler/lib/src/js_backend/kernel_task.dart b/pkg/compiler/lib/src/kernel/task.dart
similarity index 77%
rename from pkg/compiler/lib/src/js_backend/kernel_task.dart
rename to pkg/compiler/lib/src/kernel/task.dart
index 9f0c0d9..59cf0b4 100644
--- a/pkg/compiler/lib/src/js_backend/kernel_task.dart
+++ b/pkg/compiler/lib/src/kernel/task.dart
@@ -2,33 +2,35 @@
// 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 '../compiler.dart';
import '../common/names.dart';
+import '../common/tasks.dart' show CompilerTask;
+import '../compiler.dart';
import '../elements/elements.dart';
-import '../kernel/kernel.dart';
+import 'kernel.dart';
import 'package:kernel/ast.dart' as ir;
-import 'backend.dart';
-
/// Visits the compiler main function and builds the kernel representation.
///
/// This creates a mapping from kernel nodes to AST nodes to be used later.
-class KernelTask {
+class KernelTask extends CompilerTask {
+ get name => "kernel";
+
final Compiler _compiler;
final Kernel kernel;
- KernelTask(JavaScriptBackend backend)
- : this._compiler = backend.compiler,
- this.kernel = new Kernel(backend.compiler);
+ KernelTask(Compiler compiler)
+ : this._compiler = compiler,
+ this.kernel = new Kernel(compiler),
+ super(compiler.measurer);
ir.Program program;
/// Builds the kernel IR for the main function.
///
/// May enqueue more elements to the resolution queue.
- void buildKernelIr() {
+ void buildKernelIr() => measure(() {
program = buildProgram(_compiler.mainApp);
- }
+ });
/// Builds the kernel IR program for the main function exported from
/// [library].
diff --git a/pkg/compiler/lib/src/util/emptyset.dart b/pkg/compiler/lib/src/util/emptyset.dart
index da9942c..26474da 100644
--- a/pkg/compiler/lib/src/util/emptyset.dart
+++ b/pkg/compiler/lib/src/util/emptyset.dart
@@ -32,7 +32,7 @@
Set<E> union(Set<E> other) => new Set.from(other);
Set<E> intersection(Set<E> other) => this;
- Set<E> difference(Set<E> other) => this;
+ Set<E> difference(Set<Object> other) => this;
Set<E> toSet() => new Set();
}
diff --git a/pkg/compiler/lib/src/util/setlet.dart b/pkg/compiler/lib/src/util/setlet.dart
index cd654c1..c9d3fe5 100644
--- a/pkg/compiler/lib/src/util/setlet.dart
+++ b/pkg/compiler/lib/src/util/setlet.dart
@@ -250,7 +250,7 @@
Setlet<E> intersection(Set<E> other) =>
new Setlet<E>.from(this.where((e) => other.contains(e)));
- Setlet<E> difference(Set<E> other) =>
+ Setlet<E> difference(Set<Object> other) =>
new Setlet<E>.from(this.where((e) => !other.contains(e)));
Setlet<E> toSet() {
diff --git a/pkg/compiler/tool/perf.dart b/pkg/compiler/tool/perf.dart
index 51f98d6..2cd9d0c3 100644
--- a/pkg/compiler/tool/perf.dart
+++ b/pkg/compiler/tool/perf.dart
@@ -9,6 +9,10 @@
import 'dart:io';
import 'package:compiler/compiler_new.dart';
+import 'package:compiler/src/apiimpl.dart';
+import 'package:compiler/src/compiler.dart';
+import 'package:compiler/src/kernel/task.dart';
+import 'package:compiler/src/elements/elements.dart';
import 'package:compiler/src/common.dart';
import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
import 'package:compiler/src/diagnostics/messages.dart'
@@ -51,20 +55,36 @@
await setup(entryUri);
- if (bench == 'scan') {
- Set<SourceFile> files = await scanReachableFiles(entryUri);
- // TODO(sigmund): consider replacing the warmup with instrumented snapshots.
- for (int i = 0; i < 10; i++) scanFiles(files);
- } else if (bench == 'parse') {
- Set<SourceFile> files = await scanReachableFiles(entryUri);
- // TODO(sigmund): consider replacing the warmup with instrumented snapshots.
- for (int i = 0; i < 10; i++) parseFiles(files);
- } else {
- print('unsupported bench-id: $bench. Please specify "scan" or "parse"');
+ var handlers = {
+ 'scan': () async {
+ Set<SourceFile> files = await scanReachableFiles(entryUri);
+ // TODO(sigmund): replace the warmup with instrumented snapshots.
+ for (int i = 0; i < 10; i++) scanFiles(files);
+ },
+ 'parse': () async {
+ Set<SourceFile> files = await scanReachableFiles(entryUri);
+ // TODO(sigmund): replace the warmup with instrumented snapshots.
+ for (int i = 0; i < 10; i++) parseFiles(files);
+ },
+ 'kernel_gen_e2e': () async {
+ // TODO(sigmund): remove. This is used to compute the input size, we
+ // should extract input size from frontend instead.
+ await scanReachableFiles(entryUri);
+ // TODO(sigmund): replace this warmup. Note that for very large programs,
+ // the GC pressure on the VM seems to make this worse with time (maybe we
+ // are leaking memory?). That's why we run it twice and not 10 times.
+ for (int i = 0; i < 2; i++) await generateKernel(entryUri);
+ },
+ };
+
+ var handler = handlers[bench];
+ if (handler == null) {
// TODO(sigmund): implement the remaining benchmarks.
+ print('unsupported bench-id: $bench. Please specify one of the following: '
+ '${handler.keys.join(", ")}');
exit(1);
}
-
+ await handler();
totalTimer.stop();
report("total", totalTimer.elapsedMicroseconds);
}
@@ -317,3 +337,68 @@
const _ParserOptions();
bool get enableGenericMethodSyntax => true;
}
+
+generateKernel(Uri entryUri) async {
+ var timer = new Stopwatch()..start();
+ var options = new CompilerOptions(
+ entryPoint: entryUri,
+ libraryRoot: _libraryRoot,
+ packagesDiscoveryProvider: findPackages,
+ platformConfigUri: _platformConfigUri,
+ useKernel: true,
+ verbose: false); // set to true to debug internal timings
+ var inputProvider = new CompilerSourceFileProvider();
+ var diagnosticHandler = new FormattingDiagnosticHandler(inputProvider)
+ ..verbose = options.verbose;
+ var compiler = new MyCompiler(inputProvider, diagnosticHandler, options);
+ await compiler.run(entryUri);
+ timer.stop();
+ report("kernel_gen_e2e", timer.elapsedMicroseconds);
+}
+
+// We subclass compiler to skip phases and stop after creating kernel.
+class MyCompiler extends CompilerImpl {
+ MyCompiler(CompilerInput provider, CompilerDiagnostics handler,
+ CompilerOptions options)
+ : super(provider, null, handler, options) {}
+
+ /// Performs the compilation when all libraries have been loaded.
+ void compileLoadedLibraries() =>
+ selfTask.measureSubtask("KernelCompiler.compileLoadedLibraries", () {
+ computeMain();
+ mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
+
+ deferredLoadTask.beforeResolution(this);
+ impactStrategy = backend.createImpactStrategy(
+ supportDeferredLoad: deferredLoadTask.isProgramSplit,
+ supportDumpInfo: options.dumpInfo,
+ supportSerialization: serialization.supportSerialization);
+
+ phase = Compiler.PHASE_RESOLVING;
+
+ // Note: we enqueue everything in the program so we measure generating
+ // kernel for the entire code, not just what's reachable from main.
+ libraryLoader.libraries.forEach((LibraryElement library) {
+ fullyEnqueueLibrary(library, enqueuer.resolution);
+ });
+
+ backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
+ resolveLibraryMetadata();
+ reporter.log('Resolving...');
+ processQueue(enqueuer.resolution, mainFunction);
+ enqueuer.resolution.logSummary(reporter.log);
+
+ (reporter as CompilerDiagnosticReporter)
+ .reportSuppressedMessagesSummary();
+
+ if (compilationFailed) {
+ // TODO(sigmund): more diagnostics?
+ print("compilation failed!");
+ exit(1);
+ }
+
+ closeResolution();
+ var program = (backend as dynamic).kernelTask.program;
+ print('total libraries: ${program.libraries.length}');
+ });
+}
diff --git a/pkg/dev_compiler/README.md b/pkg/dev_compiler/README.md
index 7bb6066..713d45b 100644
--- a/pkg/dev_compiler/README.md
+++ b/pkg/dev_compiler/README.md
@@ -1,8 +1,8 @@
dev_compiler
============
-[](https://travis-ci.org/dart-lang/dev_compiler)
-[](https://coveralls.io/r/dart-lang/dev_compiler)
+[](https://travis-ci.org/dart-lang/sdk)
+[](https://coveralls.io/r/dart-lang/sdk)
The Dart Dev Compiler (DDC) is an **experimental** development tool and transpiler. It is at a very early stage today. Its aims include the following:
diff --git a/pkg/dev_compiler/lib/js/amd/dart_sdk.js b/pkg/dev_compiler/lib/js/amd/dart_sdk.js
index 0fcf0ec..9c95125 100644
--- a/pkg/dev_compiler/lib/js/amd/dart_sdk.js
+++ b/pkg/dev_compiler/lib/js/amd/dart_sdk.js
@@ -1036,7 +1036,6 @@
let proto = type.prototype;
for (let name of methodNames) {
let method = dart.getOwnPropertyDescriptor(proto, name);
- if (!method) continue;
dart.defineProperty(proto, dart.getExtensionSymbol(name), method);
}
let originalSigFn = dart.getOwnPropertyDescriptor(type, dart._methodSig).get;
@@ -1603,9 +1602,9 @@
dart.getDynamicStats = function() {
let ret = JSArrayOfListOfObject().of([]);
let keys = dart._callMethodStats[dartx.keys][dartx.toList]();
- keys[dartx.sort](dart.fn((a, b) => dart._callMethodStats[dartx.get](b).count[dartx.compareTo](dart._callMethodStats[dartx.get](a).count), StringAndStringToint()));
+ keys[dartx.sort](dart.fn((a, b) => dart._callMethodStats[dartx._get](b).count[dartx.compareTo](dart._callMethodStats[dartx._get](a).count), StringAndStringToint()));
for (let key of keys) {
- let stats = dart._callMethodStats[dartx.get](key);
+ let stats = dart._callMethodStats[dartx._get](key);
ret[dartx.add](JSArrayOfObject().of([stats.typeName, stats.frame, stats.count]));
}
return ret;
@@ -1620,7 +1619,7 @@
let stack = stackStr[dartx.split]('\n at ');
let src = '';
for (let i = 2; i < dart.notNull(stack[dartx.length]); ++i) {
- let frame = stack[dartx.get](i);
+ let frame = stack[dartx._get](i);
if (!dart.test(frame[dartx.contains]('dart_sdk.js'))) {
src = frame;
break;
@@ -1646,10 +1645,10 @@
return dart._callMethod(obj, method, typeArgs, args, method);
};
dart.dindex = function(obj, index) {
- return dart._callMethod(obj, 'get', null, [index], '[]');
+ return dart._callMethod(obj, '_get', null, [index], '[]');
};
dart.dsetindex = function(obj, index, value) {
- return dart._callMethod(obj, 'set', null, [index, value], '[]=');
+ return dart._callMethod(obj, '_set', null, [index, value], '[]=');
};
dart._ignoreMemo = function(f) {
let memo = new Map();
@@ -1772,11 +1771,11 @@
for (let i = 0, end = values.length - 1; i < end; i += 2) {
let key = values[i];
let value = values[i + 1];
- map.set(key, value);
+ map._set(key, value);
}
} else if (typeof values === 'object') {
for (let key of dart.getOwnPropertyNames(values)) {
- map.set(key, values[key]);
+ map._set(key, values[key]);
}
}
return map;
@@ -3116,7 +3115,7 @@
if (genericTypeConstructor != null) {
this.recordGenericParameters(core.String._check(name), genericTypeConstructor);
} else {
- nonGenericProperties.set(core.String._check(name), value);
+ nonGenericProperties._set(core.String._check(name), value);
}
}, dynamicAnddynamicTodynamic$()));
nonGenericProperties.forEach(dart.fn((name, value) => {
@@ -3129,13 +3128,13 @@
return children.toList();
}
recordGenericParameters(name, genericTypeConstructor) {
- this.genericParameters.set(name, genericTypeConstructor.toString()[dartx.split](' =>')[dartx.first][dartx.replaceAll](core.RegExp.new('[(|)]'), ''));
+ this.genericParameters._set(name, genericTypeConstructor.toString()[dartx.split](' =>')[dartx.first][dartx.replaceAll](core.RegExp.new('[(|)]'), ''));
}
classChild(name, child) {
let typeName = _debugger.getTypeName(core.Type._check(child));
let parameterName = dart.str`${name}\$`;
if (dart.test(this.genericParameters.keys[dartx.contains](parameterName))) {
- typeName = dart.str`${typeName}<${this.genericParameters.get(parameterName)}>`;
+ typeName = dart.str`${typeName}<${this.genericParameters._get(parameterName)}>`;
_debugger.JSNative.setProperty(child, 'genericTypeName', typeName);
}
return new _debugger.NameValuePair({name: typeName, value: child});
@@ -3725,8 +3724,8 @@
'hashCode',
'length',
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'asMap'
]);
class JSArray extends core.Object {
@@ -3803,7 +3802,7 @@
this[dartx.checkMutable]('setAll');
core.RangeError.checkValueInInterval(index, 0, this[dartx.length], "index");
for (let element of iterable) {
- this[dartx.set]((() => {
+ this[dartx._set]((() => {
let x = index;
index = dart.notNull(x) + 1;
return x;
@@ -3818,7 +3817,7 @@
[dartx.remove](element) {
this[dartx.checkGrowable]('remove');
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
this.splice(i, 1);
return true;
}
@@ -3846,7 +3845,7 @@
if (retained[dartx.length] == end) return;
this[dartx.length] = retained[dartx.length];
for (let i = 0; i < dart.notNull(retained[dartx.length]); i++) {
- this[dartx.set](i, E._check(retained[dartx.get](i)));
+ this[dartx._set](i, E._check(retained[dartx._get](i)));
}
}
[dartx.where](f) {
@@ -3887,7 +3886,7 @@
if (separator === void 0) separator = "";
let list = core.List.new(this[dartx.length]);
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- list[dartx.set](i, dart.str`${this[dartx.get](i)}`);
+ list[dartx._set](i, dart.str`${this[dartx._get](i)}`);
}
return list.join(separator);
}
@@ -3907,7 +3906,7 @@
EAndEToE()._check(combine);
let length = this[dartx.length];
if (length == 0) dart.throw(_internal.IterableElementError.noElement());
- let value = this[dartx.get](0);
+ let value = this[dartx._get](0);
for (let i = 1; i < dart.notNull(length); i++) {
let element = this[i];
value = combine(value, element);
@@ -3974,7 +3973,7 @@
dart.throw(_internal.IterableElementError.noElement());
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.sublist](start, end) {
if (end === void 0) end = null;
@@ -3999,15 +3998,15 @@
return new (SubListIterableOfE())(this, start, end);
}
get [dartx.first]() {
- if (dart.notNull(this[dartx.length]) > 0) return this[dartx.get](0);
+ if (dart.notNull(this[dartx.length]) > 0) return this[dartx._get](0);
dart.throw(_internal.IterableElementError.noElement());
}
get [dartx.last]() {
- if (dart.notNull(this[dartx.length]) > 0) return this[dartx.get](dart.notNull(this[dartx.length]) - 1);
+ if (dart.notNull(this[dartx.length]) > 0) return this[dartx._get](dart.notNull(this[dartx.length]) - 1);
dart.throw(_internal.IterableElementError.noElement());
}
get [dartx.single]() {
- if (this[dartx.length] == 1) return this[dartx.get](0);
+ if (this[dartx.length] == 1) return this[dartx._get](0);
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
dart.throw(_internal.IterableElementError.tooMany());
}
@@ -4039,12 +4038,12 @@
}
if (dart.notNull(otherStart) < dart.notNull(start)) {
for (let i = length - 1; i >= 0; i--) {
- let element = otherList[dartx.get](dart.notNull(otherStart) + i);
+ let element = otherList[dartx._get](dart.notNull(otherStart) + i);
this[dart.notNull(start) + i] = element;
}
} else {
for (let i = 0; i < length; i++) {
- let element = otherList[dartx.get](dart.notNull(otherStart) + i);
+ let element = otherList[dartx._get](dart.notNull(otherStart) + i);
this[dart.notNull(start) + i] = element;
}
}
@@ -4123,9 +4122,9 @@
while (dart.notNull(length) > 1) {
let pos = random.nextInt(length);
length = dart.notNull(length) - 1;
- let tmp = this[dartx.get](length);
- this[dartx.set](length, this[dartx.get](pos));
- this[dartx.set](pos, tmp);
+ let tmp = this[dartx._get](length);
+ this[dartx._set](length, this[dartx._get](pos));
+ this[dartx._set](pos, tmp);
}
}
[dartx.indexOf](element, start) {
@@ -4137,7 +4136,7 @@
start = 0;
}
for (let i = start; dart.notNull(i) < dart.notNull(this[dartx.length]); i = dart.notNull(i) + 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -4156,7 +4155,7 @@
}
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -4164,7 +4163,7 @@
}
[dartx.contains](other) {
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), other)) return true;
+ if (dart.equals(this[dartx._get](i), other)) return true;
}
return false;
}
@@ -4205,12 +4204,12 @@
}
this.length = newLength;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (!(typeof index == 'number')) dart.throw(_js_helper.diagnoseIndexError(this, index));
if (dart.notNull(index) >= dart.notNull(this[dartx.length]) || dart.notNull(index) < 0) dart.throw(_js_helper.diagnoseIndexError(this, index));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
E._check(value);
this[dartx.checkMutable]('indexed set');
if (!(typeof index == 'number')) dart.throw(_js_helper.diagnoseIndexError(this, index));
@@ -4289,8 +4288,8 @@
[dartx.contains]: dart.definiteFunctionType(core.bool, [core.Object]),
[dartx.toList]: dart.definiteFunctionType(core.List$(E), [], {growable: core.bool}),
[dartx.toSet]: dart.definiteFunctionType(core.Set$(E), []),
- [dartx.get]: dart.definiteFunctionType(E, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, E]),
+ [dartx._get]: dart.definiteFunctionType(E, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, E]),
[dartx.asMap]: dart.definiteFunctionType(core.Map$(core.int, E), [])
}),
statics: () => ({
@@ -4365,7 +4364,7 @@
this[_current] = null;
return false;
}
- this[_current] = this[_iterable][dartx.get](this[_index]);
+ this[_current] = this[_iterable][dartx._get](this[_index]);
this[_index] = dart.notNull(this[_index]) + 1;
return true;
}
@@ -4417,7 +4416,7 @@
'toRadixString',
'toString',
'hashCode',
- 'unary-',
+ '_negate',
'+',
'-',
'/',
@@ -4614,7 +4613,7 @@
get [dartx.hashCode]() {
return this & 0x1FFFFFFF;
}
- [dartx['unary-']]() {
+ [dartx._negate]() {
return -this;
}
[dartx['+']](other) {
@@ -4912,7 +4911,7 @@
[dartx.toStringAsExponential]: dart.definiteFunctionType(core.String, [], [core.int]),
[dartx.toStringAsPrecision]: dart.definiteFunctionType(core.String, [core.int]),
[dartx.toRadixString]: dart.definiteFunctionType(core.String, [core.int]),
- [dartx['unary-']]: dart.definiteFunctionType(_interceptors.JSNumber, []),
+ [dartx._negate]: dart.definiteFunctionType(_interceptors.JSNumber, []),
[dartx['+']]: dart.definiteFunctionType(_interceptors.JSNumber, [core.num]),
[dartx['-']]: dart.definiteFunctionType(_interceptors.JSNumber, [core.num]),
[dartx['/']]: dart.definiteFunctionType(core.double, [core.num]),
@@ -4995,7 +4994,7 @@
'hashCode',
'runtimeType',
'length',
- 'get'
+ '_get'
]);
_interceptors.JSString = class JSString extends _interceptors.Interceptor {
new() {
@@ -5378,7 +5377,7 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (!(typeof index == 'number')) dart.throw(_js_helper.diagnoseIndexError(this, index));
if (dart.notNull(index) >= dart.notNull(this[dartx.length]) || dart.notNull(index) < 0) dart.throw(_js_helper.diagnoseIndexError(this, index));
return this[index];
@@ -5422,7 +5421,7 @@
[dartx.lastIndexOf]: dart.definiteFunctionType(core.int, [core.Pattern], [core.int]),
[dartx.contains]: dart.definiteFunctionType(core.bool, [core.Pattern], [core.int]),
[dartx.compareTo]: dart.definiteFunctionType(core.int, [core.String]),
- [dartx.get]: dart.definiteFunctionType(core.String, [core.int])
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.int])
}),
statics: () => ({
_isWhitespace: dart.definiteFunctionType(core.bool, [core.int]),
@@ -5574,12 +5573,12 @@
return new dart.JsIterator(this[dartx.iterator]);
}
elementAt(index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
forEach(action) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- action(this[dartx.get](i));
+ action(this[dartx._get](i));
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5593,21 +5592,21 @@
}
get first() {
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
- return this[dartx.get](0);
+ return this[dartx._get](0);
}
get last() {
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
- return this[dartx.get](dart.notNull(this[dartx.length]) - 1);
+ return this[dartx._get](dart.notNull(this[dartx.length]) - 1);
}
get single() {
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
if (dart.notNull(this[dartx.length]) > 1) dart.throw(_internal.IterableElementError.tooMany());
- return this[dartx.get](0);
+ return this[dartx._get](0);
}
contains(element) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), element)) return true;
+ if (dart.equals(this[dartx._get](i), element)) return true;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5617,7 +5616,7 @@
every(test) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (!dart.test(test(this[dartx.get](i)))) return false;
+ if (!dart.test(test(this[dartx._get](i)))) return false;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5627,7 +5626,7 @@
any(test) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (dart.test(test(this[dartx.get](i)))) return true;
+ if (dart.test(test(this[dartx._get](i)))) return true;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5639,7 +5638,7 @@
VoidToE()._check(orElse);
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- let element = this[dartx.get](i);
+ let element = this[dartx._get](i);
if (dart.test(test(element))) return element;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
@@ -5653,7 +5652,7 @@
VoidToE()._check(orElse);
let length = this[dartx.length];
for (let i = dart.notNull(length) - 1; i >= 0; i--) {
- let element = this[dartx.get](i);
+ let element = this[dartx._get](i);
if (dart.test(test(element))) return element;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
@@ -5667,7 +5666,7 @@
let match = null;
let matchFound = false;
for (let i = 0; i < dart.notNull(length); i++) {
- let element = this[dartx.get](i);
+ let element = this[dartx._get](i);
if (dart.test(test(element))) {
if (matchFound) {
dart.throw(_internal.IterableElementError.tooMany());
@@ -5706,9 +5705,9 @@
EAndEToE()._check(combine);
let length = this[dartx.length];
if (length == 0) dart.throw(_internal.IterableElementError.noElement());
- let value = this[dartx.get](0);
+ let value = this[dartx._get](0);
for (let i = 1; i < dart.notNull(length); i++) {
- value = combine(value, this[dartx.get](i));
+ value = combine(value, this[dartx._get](i));
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5720,7 +5719,7 @@
let value = initialValue;
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- value = combine(value, this[dartx.get](i));
+ value = combine(value, this[dartx._get](i));
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5750,20 +5749,20 @@
result = ListOfE().new(this[dartx.length]);
}
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- result[dartx.set](i, this[dartx.get](i));
+ result[dartx._set](i, this[dartx._get](i));
}
return result;
}
toSet() {
let result = SetOfE().new();
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- result.add(this[dartx.get](i));
+ result.add(this[dartx._get](i));
}
return result;
}
add(element) {
E._check(element);
- this[dartx.set]((() => {
+ this[dartx._set]((() => {
let x = this[dartx.length];
this[dartx.length] = dart.notNull(x) + 1;
return x;
@@ -5775,13 +5774,13 @@
for (let element of iterable) {
dart.assert(this[dartx.length] == i || dart.test(dart.throw(new core.ConcurrentModificationError(this))));
this[dartx.length] = dart.notNull(i) + 1;
- this[dartx.set](i, element);
+ this[dartx._set](i, element);
i = dart.notNull(i) + 1;
}
}
remove(element) {
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
this[dartx.setRange](i, dart.notNull(this[dartx.length]) - 1, this, i + 1);
this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
return true;
@@ -5799,7 +5798,7 @@
let retained = [];
let length = source[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- let element = source[dartx.get](i);
+ let element = source[dartx._get](i);
if (dart.dcall(test, element) == retainMatching) {
retained[dartx.add](element);
}
@@ -5819,7 +5818,7 @@
if (this[dartx.length] == 0) {
dart.throw(_internal.IterableElementError.noElement());
}
- let result = this[dartx.get](dart.notNull(this[dartx.length]) - 1);
+ let result = this[dartx._get](dart.notNull(this[dartx.length]) - 1);
this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
return result;
}
@@ -5838,9 +5837,9 @@
while (dart.notNull(length) > 1) {
let pos = random.nextInt(length);
length = dart.notNull(length) - 1;
- let tmp = this[dartx.get](length);
- this[dartx.set](length, this[dartx.get](pos));
- this[dartx.set](pos, tmp);
+ let tmp = this[dartx._get](length);
+ this[dartx._set](length, this[dartx._get](pos));
+ this[dartx._set](pos, tmp);
}
}
asMap() {
@@ -5855,7 +5854,7 @@
let result = ListOfE().new();
result[dartx.length] = length;
for (let i = 0; i < length; i++) {
- result[dartx.set](i, this[dartx.get](dart.notNull(start) + i));
+ result[dartx._set](i, this[dartx._get](dart.notNull(start) + i));
}
return result;
}
@@ -5874,7 +5873,7 @@
E._check(fill);
core.RangeError.checkValidRange(start, end, this[dartx.length]);
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- this[dartx.set](i, fill);
+ this[dartx._set](i, fill);
}
}
setRange(start, end, iterable, skipCount) {
@@ -5898,11 +5897,11 @@
}
if (dart.notNull(otherStart) < dart.notNull(start)) {
for (let i = length - 1; i >= 0; i--) {
- this[dartx.set](dart.notNull(start) + i, otherList[dartx.get](dart.notNull(otherStart) + i));
+ this[dartx._set](dart.notNull(start) + i, otherList[dartx._get](dart.notNull(otherStart) + i));
}
} else {
for (let i = 0; i < length; i++) {
- this[dartx.set](dart.notNull(start) + i, otherList[dartx.get](dart.notNull(otherStart) + i));
+ this[dartx._set](dart.notNull(start) + i, otherList[dartx._get](dart.notNull(otherStart) + i));
}
}
}
@@ -5941,7 +5940,7 @@
startIndex = 0;
}
for (let i = startIndex; dart.notNull(i) < dart.notNull(this[dartx.length]); i = dart.notNull(i) + 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -5960,7 +5959,7 @@
}
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -5976,10 +5975,10 @@
if (!(typeof index == 'number')) dart.throw(new core.ArgumentError(index));
this[dartx.length] = dart.notNull(this[dartx.length]) + 1;
this[dartx.setRange](dart.notNull(index) + 1, this[dartx.length], this, index);
- this[dartx.set](index, element);
+ this[dartx._set](index, element);
}
removeAt(index) {
- let result = this[dartx.get](index);
+ let result = this[dartx._get](index);
this[dartx.setRange](index, dart.notNull(this[dartx.length]) - 1, this, dart.notNull(index) + 1);
this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
return result;
@@ -6005,7 +6004,7 @@
this[dartx.setRange](index, dart.notNull(index) + dart.notNull(iterable[dartx.length]), iterable);
} else {
for (let element of iterable) {
- this[dartx.set]((() => {
+ this[dartx._set]((() => {
let x = index;
index = dart.notNull(x) + 1;
return x;
@@ -6154,7 +6153,7 @@
let ETobool = () => (ETobool = dart.constFn(dart.functionType(core.bool, [E])))();
let ComparatorOfE = () => (ComparatorOfE = dart.constFn(core.Comparator$(E)))();
class UnmodifiableListMixin extends core.Object {
- set(index, value) {
+ _set(index, value) {
E._check(value);
dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable list"));
return value;
@@ -6231,7 +6230,7 @@
dart.setSignature(UnmodifiableListMixin, {
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
setAll: dart.definiteFunctionType(dart.void, [core.int, IterableOfE()]),
add: dart.definiteFunctionType(dart.void, [E]),
insert: dart.definiteFunctionType(dart.void, [core.int, E]),
@@ -6252,7 +6251,7 @@
})
});
dart.defineExtensionMembers(UnmodifiableListMixin, [
- 'set',
+ '_set',
'setAll',
'add',
'insert',
@@ -6321,7 +6320,7 @@
set length(value) {
super.length = value;
}
- get(i) {
+ _get(i) {
return this[_string][dartx.codeUnitAt](i);
}
static stringOf(u) {
@@ -6333,11 +6332,11 @@
constructors: () => ({new: dart.definiteFunctionType(_internal.CodeUnits, [core.String])}),
fields: () => ({[_string]: core.String}),
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
- methods: () => ({get: dart.definiteFunctionType(core.int, [core.int])}),
+ methods: () => ({_get: dart.definiteFunctionType(core.int, [core.int])}),
statics: () => ({stringOf: dart.definiteFunctionType(core.String, [_internal.CodeUnits])}),
names: ['stringOf']
});
- dart.defineExtensionMembers(_internal.CodeUnits, ['get', 'length']);
+ dart.defineExtensionMembers(_internal.CodeUnits, ['_get', 'length']);
_internal.EfficientLength = class EfficientLength extends core.Object {};
core.Iterable$ = dart.generic(E => {
let EmptyIterableOfE = () => (EmptyIterableOfE = dart.constFn(_internal.EmptyIterable$(E)))();
@@ -6856,7 +6855,7 @@
result = ListOfE().new(this.length);
}
for (let i = 0; i < dart.notNull(this.length); i++) {
- result[dartx.set](i, this.elementAt(i));
+ result[dartx._set](i, this.elementAt(i));
}
return result;
}
@@ -7004,7 +7003,7 @@
return _;
})() : ListOfE().new(length);
for (let i = 0; i < length; i++) {
- result[dartx.set](i, this[_iterable$][dartx.elementAt](dart.notNull(start) + i));
+ result[dartx._set](i, this[_iterable$][dartx.elementAt](dart.notNull(start) + i));
if (dart.notNull(this[_iterable$][dartx.length]) < dart.notNull(end)) dart.throw(new core.ConcurrentModificationError(this));
}
return result;
@@ -8054,8 +8053,8 @@
new(values) {
this[_values] = values;
}
- get(key) {
- return dart.test(this.containsKey(key)) ? this[_values][dartx.get](core.int._check(key)) : null;
+ _get(key) {
+ return dart.test(this.containsKey(key)) ? this[_values][dartx._get](core.int._check(key)) : null;
}
get length() {
return this[_values][dartx.length];
@@ -8081,13 +8080,13 @@
forEach(f) {
let length = this[_values][dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- f(i, this[_values][dartx.get](i));
+ f(i, this[_values][dartx._get](i));
if (length != this[_values][dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this[_values]));
}
}
}
- set(key, value) {
+ _set(key, value) {
E._check(value);
dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable map"));
return value;
@@ -8123,11 +8122,11 @@
isNotEmpty: dart.definiteFunctionType(core.bool, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(E, [core.Object]),
+ _get: dart.definiteFunctionType(E, [core.Object]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
forEach: dart.definiteFunctionType(dart.void, [intAndETovoid()]),
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
putIfAbsent: dart.definiteFunctionType(E, [core.int, VoidToE()]),
remove: dart.definiteFunctionType(E, [core.Object]),
clear: dart.definiteFunctionType(dart.void, []),
@@ -8135,11 +8134,11 @@
})
});
dart.defineExtensionMembers(ListMapView, [
- 'get',
+ '_get',
'containsValue',
'containsKey',
'forEach',
- 'set',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -8236,11 +8235,11 @@
static copy(src, srcStart, dst, dstStart, count) {
if (dart.notNull(srcStart) < dart.notNull(dstStart)) {
for (let i = dart.notNull(srcStart) + dart.notNull(count) - 1, j = dart.notNull(dstStart) + dart.notNull(count) - 1; i >= dart.notNull(srcStart); i--, j--) {
- dst[dartx.set](j, src[dartx.get](i));
+ dst[dartx._set](j, src[dartx._get](i));
}
} else {
for (let i = srcStart, j = dstStart; dart.notNull(i) < dart.notNull(srcStart) + dart.notNull(count); i = dart.notNull(i) + 1, j = dart.notNull(j) + 1) {
- dst[dartx.set](j, src[dartx.get](i));
+ dst[dartx._set](j, src[dartx._get](i));
}
}
}
@@ -8250,7 +8249,7 @@
let length = a[dartx.length];
if (!dart.equals(length, dart.dload(b, 'length'))) return false;
for (let i = 0; i < dart.notNull(length); i++) {
- if (!core.identical(a[dartx.get](i), dart.dindex(b, i))) return false;
+ if (!core.identical(a[dartx._get](i), dart.dindex(b, i))) return false;
}
return true;
}
@@ -8262,7 +8261,7 @@
startIndex = 0;
}
for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dart.notNull(i) + 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -8276,7 +8275,7 @@
startIndex = dart.notNull(a[dartx.length]) - 1;
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -8336,13 +8335,13 @@
static _insertionSort(E) {
return (a, left, right, compare) => {
for (let i = dart.notNull(left) + 1; i <= dart.notNull(right); i++) {
- let el = a[dartx.get](i);
+ let el = a[dartx._get](i);
let j = i;
- while (j > dart.notNull(left) && dart.notNull(compare(a[dartx.get](j - 1), el)) > 0) {
- a[dartx.set](j, a[dartx.get](j - 1));
+ while (j > dart.notNull(left) && dart.notNull(compare(a[dartx._get](j - 1), el)) > 0) {
+ a[dartx._set](j, a[dartx._get](j - 1));
j--;
}
- a[dartx.set](j, el);
+ a[dartx._set](j, el);
}
};
}
@@ -8355,11 +8354,11 @@
let index3 = ((dart.notNull(left) + dart.notNull(right)) / 2)[dartx.truncate]();
let index2 = index3 - sixth;
let index4 = index3 + sixth;
- let el1 = a[dartx.get](index1);
- let el2 = a[dartx.get](index2);
- let el3 = a[dartx.get](index3);
- let el4 = a[dartx.get](index4);
- let el5 = a[dartx.get](index5);
+ let el1 = a[dartx._get](index1);
+ let el2 = a[dartx._get](index2);
+ let el3 = a[dartx._get](index3);
+ let el4 = a[dartx._get](index4);
+ let el5 = a[dartx._get](index5);
if (dart.notNull(compare(el1, el2)) > 0) {
let t = el1;
el1 = el2;
@@ -8407,40 +8406,40 @@
}
let pivot1 = el2;
let pivot2 = el4;
- a[dartx.set](index1, el1);
- a[dartx.set](index3, el3);
- a[dartx.set](index5, el5);
- a[dartx.set](index2, a[dartx.get](left));
- a[dartx.set](index4, a[dartx.get](right));
+ a[dartx._set](index1, el1);
+ a[dartx._set](index3, el3);
+ a[dartx._set](index5, el5);
+ a[dartx._set](index2, a[dartx._get](left));
+ a[dartx._set](index4, a[dartx._get](right));
let less = dart.notNull(left) + 1;
let great = dart.notNull(right) - 1;
let pivots_are_equal = compare(pivot1, pivot2) == 0;
if (pivots_are_equal) {
let pivot = pivot1;
for (let k = less; k <= great; k++) {
- let ak = a[dartx.get](k);
+ let ak = a[dartx._get](k);
let comp = compare(ak, pivot);
if (comp == 0) continue;
if (dart.notNull(comp) < 0) {
if (k != less) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less, ak);
}
less++;
} else {
while (true) {
- comp = compare(a[dartx.get](great), pivot);
+ comp = compare(a[dartx._get](great), pivot);
if (dart.notNull(comp) > 0) {
great--;
continue;
} else if (dart.notNull(comp) < 0) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less++, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less++, a[dartx._get](great));
+ a[dartx._set](great--, ak);
break;
} else {
- a[dartx.set](k, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](great));
+ a[dartx._set](great--, ak);
break;
}
}
@@ -8448,32 +8447,32 @@
}
} else {
for (let k = less; k <= great; k++) {
- let ak = a[dartx.get](k);
+ let ak = a[dartx._get](k);
let comp_pivot1 = compare(ak, pivot1);
if (dart.notNull(comp_pivot1) < 0) {
if (k != less) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less, ak);
}
less++;
} else {
let comp_pivot2 = compare(ak, pivot2);
if (dart.notNull(comp_pivot2) > 0) {
while (true) {
- let comp = compare(a[dartx.get](great), pivot2);
+ let comp = compare(a[dartx._get](great), pivot2);
if (dart.notNull(comp) > 0) {
great--;
if (great < k) break;
continue;
} else {
- comp = compare(a[dartx.get](great), pivot1);
+ comp = compare(a[dartx._get](great), pivot1);
if (dart.notNull(comp) < 0) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less++, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less++, a[dartx._get](great));
+ a[dartx._set](great--, ak);
} else {
- a[dartx.set](k, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](great));
+ a[dartx._set](great--, ak);
}
break;
}
@@ -8482,49 +8481,49 @@
}
}
}
- a[dartx.set](left, a[dartx.get](less - 1));
- a[dartx.set](less - 1, pivot1);
- a[dartx.set](right, a[dartx.get](great + 1));
- a[dartx.set](great + 1, pivot2);
+ a[dartx._set](left, a[dartx._get](less - 1));
+ a[dartx._set](less - 1, pivot1);
+ a[dartx._set](right, a[dartx._get](great + 1));
+ a[dartx._set](great + 1, pivot2);
_internal.Sort._doSort(E)(a, left, less - 2, compare);
_internal.Sort._doSort(E)(a, great + 2, right, compare);
if (pivots_are_equal) {
return;
}
if (less < index1 && great > index5) {
- while (compare(a[dartx.get](less), pivot1) == 0) {
+ while (compare(a[dartx._get](less), pivot1) == 0) {
less++;
}
- while (compare(a[dartx.get](great), pivot2) == 0) {
+ while (compare(a[dartx._get](great), pivot2) == 0) {
great--;
}
for (let k = less; k <= great; k++) {
- let ak = a[dartx.get](k);
+ let ak = a[dartx._get](k);
let comp_pivot1 = compare(ak, pivot1);
if (comp_pivot1 == 0) {
if (k != less) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less, ak);
}
less++;
} else {
let comp_pivot2 = compare(ak, pivot2);
if (comp_pivot2 == 0) {
while (true) {
- let comp = compare(a[dartx.get](great), pivot2);
+ let comp = compare(a[dartx._get](great), pivot2);
if (comp == 0) {
great--;
if (great < k) break;
continue;
} else {
- comp = compare(a[dartx.get](great), pivot1);
+ comp = compare(a[dartx._get](great), pivot1);
if (dart.notNull(comp) < 0) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less++, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less++, a[dartx._get](great));
+ a[dartx._set](great--, ak);
} else {
- a[dartx.set](k, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](great));
+ a[dartx._set](great--, ak);
}
break;
}
@@ -8899,8 +8898,8 @@
return;
}
let message = core.List.new(2);
- message[dartx.set](0, dart.toString(error));
- message[dartx.set](1, stackTrace == null ? null : dart.toString(stackTrace));
+ message[dartx._set](0, dart.toString(error));
+ message[dartx._set](1, stackTrace == null ? null : dart.toString(stackTrace));
for (let port of this.errorPorts)
port.send(message);
}
@@ -8988,13 +8987,13 @@
}
}
lookup(portId) {
- return this.ports[dartx.get](portId);
+ return this.ports[dartx._get](portId);
}
[_addRegistration](portId, port) {
if (dart.test(this.ports[dartx.containsKey](portId))) {
dart.throw(core.Exception.new("Registry: ports must be registered only once."));
}
- this.ports[dartx.set](portId, port);
+ this.ports[dartx._set](portId, port);
}
register(portId, port) {
this[_addRegistration](portId, port);
@@ -9006,7 +9005,7 @@
}
[_updateGlobalState]() {
if (dart.notNull(this.ports[dartx.length]) - dart.notNull(this.weakPorts.length) > 0 || dart.test(this.isPaused) || !dart.test(this.initialized)) {
- _isolate_helper._globalState.isolates[dartx.set](this.id, this);
+ _isolate_helper._globalState.isolates[dartx._set](this.id, this);
} else {
this.kill();
}
@@ -9291,7 +9290,7 @@
}
case 'close':
{
- _isolate_helper._globalState.managers[dartx.remove](_isolate_helper.IsolateNatives.workerIds.get(sender));
+ _isolate_helper._globalState.managers[dartx.remove](_isolate_helper.IsolateNatives.workerIds._get(sender));
sender.terminate();
_isolate_helper._globalState.topEventLoop.run();
break;
@@ -9454,8 +9453,8 @@
let o = _isolate_helper._globalState;
let workerId = o.nextManagerId;
o.nextManagerId = dart.notNull(workerId) + 1;
- _isolate_helper.IsolateNatives.workerIds.set(worker, workerId);
- _isolate_helper._globalState.managers[dartx.set](workerId, worker);
+ _isolate_helper.IsolateNatives.workerIds._set(worker, workerId);
+ _isolate_helper._globalState.managers[dartx._set](workerId, worker);
worker.postMessage(_isolate_helper._serializeMessage(dart.map({command: 'start', id: workerId, replyTo: _isolate_helper._serializeMessage(replyPort), args: args, msg: _isolate_helper._serializeMessage(message), isSpawnUri: isSpawnUri, startPaused: startPaused, functionName: functionName}, core.String, core.Object)));
}
static workerOnError(event, uri, onError) {
@@ -9538,7 +9537,7 @@
super.new(isolateId);
}
send(message) {
- let isolate = _isolate_helper._globalState.isolates[dartx.get](this[_isolateId]);
+ let isolate = _isolate_helper._globalState.isolates[dartx._get](this[_isolateId]);
if (isolate == null) return;
if (dart.test(this[_receivePort][_isClosed])) return;
let msg = _isolate_helper._clone(message);
@@ -9578,7 +9577,7 @@
if (dart.test(_isolate_helper._globalState.isWorker)) {
_isolate_helper._globalState.mainManager.postMessage(workerMessage);
} else {
- let manager = _isolate_helper._globalState.managers[dartx.get](this[_workerId]);
+ let manager = _isolate_helper._globalState.managers[dartx._get](this[_workerId]);
if (manager != null) {
manager.postMessage(workerMessage);
}
@@ -10616,10 +10615,10 @@
}
serialize(x) {
if (dart.test(this.isPrimitive(x))) return this.serializePrimitive(x);
- let serializationId = this.serializedObjectIds[dartx.get](x);
+ let serializationId = this.serializedObjectIds[dartx._get](x);
if (serializationId != null) return this.makeRef(serializationId);
serializationId = this.serializedObjectIds[dartx.length];
- this.serializedObjectIds[dartx.set](x, serializationId);
+ this.serializedObjectIds[dartx._set](x, serializationId);
if (_native_typed_data.NativeByteBuffer.is(x)) return this.serializeByteBuffer(x);
if (_native_typed_data.NativeTypedData.is(x)) return this.serializeTypedData(x);
if (_interceptors.JSIndexable.is(x)) return this.serializeJSIndexable(x);
@@ -10668,13 +10667,13 @@
let serialized = [];
serialized[dartx.length] = x[dartx.length];
for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
- serialized[dartx.set](i, this.serialize(x[dartx.get](i)));
+ serialized[dartx._set](i, this.serialize(x[dartx._get](i)));
}
return serialized;
}
serializeArrayInPlace(x) {
for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
- x[dartx.set](i, this.serialize(x[dartx.get](i)));
+ x[dartx._set](i, this.serialize(x[dartx._get](i)));
}
return x;
}
@@ -10690,7 +10689,7 @@
let values = [];
values[dartx.length] = keys[dartx.length];
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- values[dartx.set](i, this.serialize(x[keys[dartx.get](i)]));
+ values[dartx._set](i, this.serialize(x[keys[dartx._get](i)]));
}
return JSArrayOfObject().of(['js-object', keys, values]);
}
@@ -10829,7 +10828,7 @@
deserializeRef(x) {
dart.assert(dart.equals(dart.dindex(x, 0), 'ref'));
let serializationId = core.int._check(dart.dindex(x, 1));
- return this.deserializedObjects[dartx.get](serializationId);
+ return this.deserializedObjects[dartx._get](serializationId);
}
deserializeByteBuffer(x) {
dart.assert(dart.equals(dart.dindex(x, 0), 'buffer'));
@@ -10845,7 +10844,7 @@
}
deserializeArrayInPlace(x) {
for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
- x[dartx.set](i, this.deserialize(x[dartx.get](i)));
+ x[dartx._set](i, this.deserialize(x[dartx._get](i)));
}
return x;
}
@@ -10874,14 +10873,14 @@
return _interceptors.JSArray.markFixed(this.deserializeArrayInPlace(_interceptors.JSArray._check(result)));
}
deserializeMap(x) {
- dart.assert(dart.equals(x.get(0), 'map'));
- let keys = core.List._check(x.get(1));
- let values = core.List._check(x.get(2));
+ dart.assert(dart.equals(x._get(0), 'map'));
+ let keys = core.List._check(x._get(1));
+ let values = core.List._check(x._get(2));
let result = dart.map();
this.deserializedObjects[dartx.add](result);
keys = keys[dartx.map](dart.dynamic)(dart.bind(this, 'deserialize'))[dartx.toList]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- result[dartx.set](keys[dartx.get](i), this.deserialize(values[dartx.get](i)));
+ result[dartx._set](keys[dartx._get](i), this.deserialize(values[dartx._get](i)));
}
return result;
}
@@ -10892,7 +10891,7 @@
let receivePortId = core.int._check(dart.dindex(x, 3));
let result = null;
if (managerId == _isolate_helper._globalState.currentManagerId) {
- let isolate = _isolate_helper._globalState.isolates[dartx.get](isolateId);
+ let isolate = _isolate_helper._globalState.isolates[dartx._get](isolateId);
if (isolate == null) return null;
let receivePort = isolate.lookup(receivePortId);
if (receivePort == null) return null;
@@ -10916,7 +10915,7 @@
let o = {};
this.deserializedObjects[dartx.add](o);
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- o[keys[dartx.get](i)] = this.deserialize(values[dartx.get](i));
+ o[keys[dartx._get](i)] = this.deserialize(values[dartx._get](i));
}
return o;
}
@@ -11040,12 +11039,12 @@
if (match == null) {
return _js_helper.Primitives._parseIntError(source, handleError);
}
- let decimalMatch = match[dartx.get](decimalIndex);
+ let decimalMatch = match[dartx._get](decimalIndex);
if (radix == null) {
if (decimalMatch != null) {
return parseInt(source, 10);
}
- if (match[dartx.get](hexIndex) != null) {
+ if (match[dartx._get](hexIndex) != null) {
return parseInt(source, 16);
}
return _js_helper.Primitives._parseIntError(source, handleError);
@@ -11066,7 +11065,7 @@
} else {
maxCharCode = 97 - 10 - 1 + dart.notNull(radix);
}
- dart.assert(typeof match[dartx.get](digitsIndex) == 'string');
+ dart.assert(typeof match[dartx._get](digitsIndex) == 'string');
let digitsPart = match[digitsIndex];
for (let i = 0; i < dart.notNull(digitsPart[dartx.length]); i++) {
let characterCode = (dart.notNull(digitsPart[dartx.codeUnitAt](i)) | 32) >>> 0;
@@ -11204,11 +11203,11 @@
static getTimeZoneName(receiver) {
let d = _js_helper.Primitives.lazyAsJsDate(receiver);
let match = /\((.*)\)/.exec(d.toString());
- if (match != null) return core.String._check(match[dartx.get](1));
+ if (match != null) return core.String._check(match[dartx._get](1));
match = /^[A-Z,a-z]{3}\s[A-Z,a-z]{3}\s\d+\s\d{2}:\d{2}:\d{2}\s([A-Z]{3,5})\s\d{4}$/.exec(d.toString());
- if (match != null) return core.String._check(match[dartx.get](1));
+ if (match != null) return core.String._check(match[dartx._get](1));
match = /(?:GMT|UTC)[+-]\d{4}/.exec(d.toString());
- if (match != null) return core.String._check(match[dartx.get](0));
+ if (match != null) return core.String._check(match[dartx._get](0));
return "";
}
static getTimeZoneOffsetInMinutes(receiver) {
@@ -11560,7 +11559,7 @@
while (index < dart.notNull(length)) {
let key = _js_helper.getIndex(keyValuePairs, index++);
let value = _js_helper.getIndex(keyValuePairs, index++);
- result[dartx.set](key, value);
+ result[dartx._set](key, value);
}
return result;
};
@@ -11964,7 +11963,7 @@
return new (LinkedHashMapKeyIterableOfK())(this);
}
get values() {
- return MappedIterableOfK$V().new(this.keys, dart.fn(each => this.get(each), KToV()));
+ return MappedIterableOfK$V().new(this.keys, dart.fn(each => this._get(each), KToV()));
}
containsKey(key) {
if (dart.test(_js_helper.JsLinkedHashMap._isStringKey(key))) {
@@ -11986,15 +11985,15 @@
return dart.notNull(this.internalFindBucketIndex(bucket, key)) >= 0;
}
containsValue(value) {
- return this.keys[dartx.any](dart.fn(each => dart.equals(this.get(each), value), KTobool()));
+ return this.keys[dartx.any](dart.fn(each => dart.equals(this._get(each), value), KTobool()));
}
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
- get(key) {
+ _get(key) {
if (dart.test(_js_helper.JsLinkedHashMap._isStringKey(key))) {
let strings = this[_strings];
if (strings == null) return null;
@@ -12018,7 +12017,7 @@
let cell = bucket[index];
return cell.hashMapCellValue;
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
if (dart.test(_js_helper.JsLinkedHashMap._isStringKey(key))) {
@@ -12058,9 +12057,9 @@
putIfAbsent(key, ifAbsent) {
K._check(key);
VoidToV()._check(ifAbsent);
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
@@ -12233,9 +12232,9 @@
internalContainsKey: dart.definiteFunctionType(core.bool, [core.Object]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
- get: dart.definiteFunctionType(V, [core.Object]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
internalGet: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
internalSet: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
remove: dart.definiteFunctionType(V, [core.Object]),
@@ -12267,8 +12266,8 @@
'containsKey',
'containsValue',
'addAll',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -12555,7 +12554,7 @@
regexp.lastIndex = start;
let match = regexp.exec(string);
if (match == null) return null;
- if (match[dartx.get](dart.notNull(match[dartx.length]) - 1) != null) return null;
+ if (match[dartx._get](dart.notNull(match[dartx.length]) - 1) != null) return null;
match[dartx.length] = dart.notNull(match[dartx.length]) - 1;
return new _js_helper._MatchImplementation(this, ListOfString()._check(match));
}
@@ -12618,12 +12617,12 @@
return this[_match].index;
}
get end() {
- return dart.notNull(this.start) + dart.notNull(this[_match][dartx.get](0)[dartx.length]);
+ return dart.notNull(this.start) + dart.notNull(this[_match][dartx._get](0)[dartx.length]);
}
group(index) {
- return this[_match][dartx.get](index);
+ return this[_match][dartx._get](index);
}
- get(index) {
+ _get(index) {
return this.group(index);
}
get groupCount() {
@@ -12652,7 +12651,7 @@
}),
methods: () => ({
group: dart.definiteFunctionType(core.String, [core.int]),
- get: dart.definiteFunctionType(core.String, [core.int]),
+ _get: dart.definiteFunctionType(core.String, [core.int]),
groups: dart.definiteFunctionType(core.List$(core.String), [ListOfint()])
})
});
@@ -12754,7 +12753,7 @@
get end() {
return dart.notNull(this.start) + dart.notNull(this.pattern[dartx.length]);
}
- get(g) {
+ _get(g) {
return this.group(g);
}
get groupCount() {
@@ -12787,7 +12786,7 @@
groupCount: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(core.String, [core.int]),
+ _get: dart.definiteFunctionType(core.String, [core.int]),
group: dart.definiteFunctionType(core.String, [core.int]),
groups: dart.definiteFunctionType(core.List$(core.String), [ListOfint()])
})
@@ -12910,7 +12909,7 @@
let length = receiver[dartx.length];
result.write(replacement);
for (let i = 0; i < dart.notNull(length); i++) {
- result.write(receiver[dartx.get](i));
+ result.write(receiver[dartx._get](i));
result.write(replacement);
}
return result.toString();
@@ -12930,7 +12929,7 @@
};
dart.lazyFn(_js_helper.stringReplaceAllUnchecked, () => StringAndPatternAndStringToString());
_js_helper._matchString = function(match) {
- return match.get(0);
+ return match._get(0);
};
dart.lazyFn(_js_helper._matchString, () => MatchToString$());
_js_helper._stringIdentity = function(string) {
@@ -12973,7 +12972,7 @@
continue;
}
}
- buffer.write(onNonMatch(receiver[dartx.get](i)));
+ buffer.write(onNonMatch(receiver[dartx._get](i)));
i++;
}
buffer.write(onMatch(new _js_helper.StringMatch(i, receiver, "")));
@@ -13142,7 +13141,7 @@
let privateMembers = Object.getOwnPropertySymbols(data);
for (let member of core.Iterable._check(privateMembers)) {
let name = _js_mirrors._getNameForESSymbol(member);
- map[dartx.set](name, data[member]);
+ map[dartx._set](name, data[member]);
}
return map;
};
@@ -13429,13 +13428,13 @@
let constructors = _js_mirrors._getConstructors(unwrapped);
constructors[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
}, StringAnddynamicTovoid()));
if (dart.test(constructors[dartx.isEmpty])) {
let name = 'new';
let ft = _js_mirrors._defaultConstructorType(_js_mirrors._unwrap(this[_cls]));
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
}
let fields = _js_mirrors._getFields(unwrapped);
fields[dartx.forEach](dart.fn((name, t) => {
@@ -13445,23 +13444,23 @@
metadata = core.List._check(dart.dsend(dart.dsend(t, 'skip', 1), 'toList'));
t = dart.dindex(t, 0);
}
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
}, StringAnddynamicTovoid()));
let methods = _js_mirrors._getMethods(unwrapped);
methods[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let getters = _js_mirrors._getGetters(unwrapped);
getters[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let setters = _js_mirrors._getSetters(unwrapped);
setters[dartx.forEach](dart.fn((name, ft) => {
name = dart.notNull(name) + '=';
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let staticFields = _js_mirrors._getStaticFields(unwrapped);
staticFields[dartx.forEach](dart.fn((name, t) => {
@@ -13471,22 +13470,22 @@
metadata = core.List._check(dart.dsend(dart.dsend(t, 'skip', 1), 'toList'));
t = dart.dindex(t, 0);
}
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
}, StringAnddynamicTovoid()));
let statics = _js_mirrors._getStatics(unwrapped);
statics[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let staticGetters = _js_mirrors._getStaticGetters(unwrapped);
staticGetters[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let staticSetters = _js_mirrors._getStaticSetters(unwrapped);
staticSetters[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
}, StringAnddynamicTovoid()));
this[_declarations] = MapOfSymbol$DeclarationMirror().unmodifiable(this[_declarations]);
}
@@ -13798,16 +13797,16 @@
let opts = core.List._check(dart.dload(ftype, 'optionals'));
let params = ListOfParameterMirror().new(dart.notNull(args[dartx.length]) + dart.notNull(opts[dartx.length]));
for (let i = 0; i < dart.notNull(args[dartx.length]); ++i) {
- let type = args[dartx.get](i);
+ let type = args[dartx._get](i);
let metadata = dart.dindex(dart.dload(ftype, 'metadata'), i);
let param = new _js_mirrors.JsParameterMirror._('', core.Type._check(_js_mirrors._wrap(type)), core.List._check(metadata));
- params[dartx.set](i, param);
+ params[dartx._set](i, param);
}
for (let i = 0; i < dart.notNull(opts[dartx.length]); ++i) {
- let type = opts[dartx.get](i);
+ let type = opts[dartx._get](i);
let metadata = dart.dindex(dart.dload(ftype, 'metadata'), dart.notNull(args[dartx.length]) + i);
let param = new _js_mirrors.JsParameterMirror._('', core.Type._check(_js_mirrors._wrap(type)), core.List._check(metadata));
- params[dartx.set](i + dart.notNull(args[dartx.length]), param);
+ params[dartx._set](i + dart.notNull(args[dartx.length]), param);
}
this[_params] = ListOfParameterMirror().unmodifiable(params);
}
@@ -14641,11 +14640,11 @@
_slowFromList(list) {
this[_storage] = _native_typed_data.NativeFloat32List.new(dart.notNull(list[dartx.length]) * 4);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- let e = list[dartx.get](i);
- this[_storage][dartx.set](i * 4 + 0, e.x);
- this[_storage][dartx.set](i * 4 + 1, e.y);
- this[_storage][dartx.set](i * 4 + 2, e.z);
- this[_storage][dartx.set](i * 4 + 3, e.w);
+ let e = list[dartx._get](i);
+ this[_storage][dartx._set](i * 4 + 0, e.x);
+ this[_storage][dartx._set](i * 4 + 1, e.y);
+ this[_storage][dartx._set](i * 4 + 2, e.z);
+ this[_storage][dartx._set](i * 4 + 3, e.w);
}
}
get runtimeType() {
@@ -14676,20 +14675,20 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this.length);
- let _x = this[_storage][dartx.get](dart.notNull(index) * 4 + 0);
- let _y = this[_storage][dartx.get](dart.notNull(index) * 4 + 1);
- let _z = this[_storage][dartx.get](dart.notNull(index) * 4 + 2);
- let _w = this[_storage][dartx.get](dart.notNull(index) * 4 + 3);
+ let _x = this[_storage][dartx._get](dart.notNull(index) * 4 + 0);
+ let _y = this[_storage][dartx._get](dart.notNull(index) * 4 + 1);
+ let _z = this[_storage][dartx._get](dart.notNull(index) * 4 + 2);
+ let _w = this[_storage][dartx._get](dart.notNull(index) * 4 + 3);
return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this.length);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 0, value.x);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 1, value.y);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 2, value.z);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 3, value.w);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 0, value.x);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 1, value.y);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 2, value.z);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 3, value.w);
return value;
}
sublist(start, end) {
@@ -14717,14 +14716,14 @@
length: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(typed_data.Float32x4, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float32x4]),
+ _get: dart.definiteFunctionType(typed_data.Float32x4, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float32x4]),
sublist: dart.definiteFunctionType(core.List$(typed_data.Float32x4), [core.int], [core.int])
})
});
dart.defineExtensionMembers(_native_typed_data.NativeFloat32x4List, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sublist',
'buffer',
'lengthInBytes',
@@ -15274,11 +15273,11 @@
_slowFromList(list) {
this[_storage] = _native_typed_data.NativeInt32List.new(dart.notNull(list[dartx.length]) * 4);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- let e = list[dartx.get](i);
- this[_storage][dartx.set](i * 4 + 0, e.x);
- this[_storage][dartx.set](i * 4 + 1, e.y);
- this[_storage][dartx.set](i * 4 + 2, e.z);
- this[_storage][dartx.set](i * 4 + 3, e.w);
+ let e = list[dartx._get](i);
+ this[_storage][dartx._set](i * 4 + 0, e.x);
+ this[_storage][dartx._set](i * 4 + 1, e.y);
+ this[_storage][dartx._set](i * 4 + 2, e.z);
+ this[_storage][dartx._set](i * 4 + 3, e.w);
}
}
get runtimeType() {
@@ -15309,20 +15308,20 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this.length);
- let _x = this[_storage][dartx.get](dart.notNull(index) * 4 + 0);
- let _y = this[_storage][dartx.get](dart.notNull(index) * 4 + 1);
- let _z = this[_storage][dartx.get](dart.notNull(index) * 4 + 2);
- let _w = this[_storage][dartx.get](dart.notNull(index) * 4 + 3);
+ let _x = this[_storage][dartx._get](dart.notNull(index) * 4 + 0);
+ let _y = this[_storage][dartx._get](dart.notNull(index) * 4 + 1);
+ let _z = this[_storage][dartx._get](dart.notNull(index) * 4 + 2);
+ let _w = this[_storage][dartx._get](dart.notNull(index) * 4 + 3);
return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this.length);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 0, value.x);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 1, value.y);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 2, value.z);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 3, value.w);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 0, value.x);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 1, value.y);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 2, value.z);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 3, value.w);
return value;
}
sublist(start, end) {
@@ -15350,14 +15349,14 @@
length: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Int32x4]),
+ _get: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Int32x4]),
sublist: dart.definiteFunctionType(core.List$(typed_data.Int32x4), [core.int], [core.int])
})
});
dart.defineExtensionMembers(_native_typed_data.NativeInt32x4List, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sublist',
'buffer',
'lengthInBytes',
@@ -15397,9 +15396,9 @@
_slowFromList(list) {
this[_storage] = _native_typed_data.NativeFloat64List.new(dart.notNull(list[dartx.length]) * 2);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- let e = list[dartx.get](i);
- this[_storage][dartx.set](i * 2 + 0, e.x);
- this[_storage][dartx.set](i * 2 + 1, e.y);
+ let e = list[dartx._get](i);
+ this[_storage][dartx._set](i * 2 + 0, e.x);
+ this[_storage][dartx._set](i * 2 + 1, e.y);
}
}
static fromList(list) {
@@ -15430,16 +15429,16 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this.length);
- let _x = this[_storage][dartx.get](dart.notNull(index) * 2 + 0);
- let _y = this[_storage][dartx.get](dart.notNull(index) * 2 + 1);
+ let _x = this[_storage][dartx._get](dart.notNull(index) * 2 + 0);
+ let _y = this[_storage][dartx._get](dart.notNull(index) * 2 + 1);
return typed_data.Float64x2.new(_x, _y);
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this.length);
- this[_storage][dartx.set](dart.notNull(index) * 2 + 0, value.x);
- this[_storage][dartx.set](dart.notNull(index) * 2 + 1, value.y);
+ this[_storage][dartx._set](dart.notNull(index) * 2 + 0, value.x);
+ this[_storage][dartx._set](dart.notNull(index) * 2 + 1, value.y);
return value;
}
sublist(start, end) {
@@ -15467,14 +15466,14 @@
length: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(typed_data.Float64x2, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float64x2]),
+ _get: dart.definiteFunctionType(typed_data.Float64x2, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float64x2]),
sublist: dart.definiteFunctionType(core.List$(typed_data.Float64x2), [core.int], [core.int])
})
});
dart.defineExtensionMembers(_native_typed_data.NativeFloat64x2List, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sublist',
'buffer',
'lengthInBytes',
@@ -15551,7 +15550,7 @@
if (_interceptors.JSIndexable.is(list)) return list;
let result = core.List.new(list[dartx.length]);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- result[dartx.set](i, list[dartx.get](i));
+ result[dartx._set](i, list[dartx._get](i));
}
return result;
};
@@ -15801,8 +15800,8 @@
});
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'setRange'
]);
_native_typed_data.NativeTypedArrayOfDouble = class NativeTypedArrayOfDouble extends dart.mixin(_native_typed_data.NativeTypedArray, collection.ListMixin$(core.double), _internal.FixedLengthListMixin$(core.double)) {
@@ -15812,11 +15811,11 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
this[index] = value;
return value;
@@ -15833,15 +15832,15 @@
dart.setSignature(_native_typed_data.NativeTypedArrayOfDouble, {
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
- get: dart.definiteFunctionType(core.double, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, core.num]),
+ _get: dart.definiteFunctionType(core.double, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, core.num]),
setRange: dart.definiteFunctionType(dart.void, [core.int, core.int, IterableOfdouble()], [core.int])
})
});
- dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfDouble, ['get', 'set', 'setRange', 'length']);
+ dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfDouble, ['_get', '_set', 'setRange', 'length']);
dart.defineExtensionNames([
'length',
- 'set',
+ '_set',
'setRange'
]);
_native_typed_data.NativeTypedArrayOfInt = class NativeTypedArrayOfInt extends dart.mixin(_native_typed_data.NativeTypedArray, collection.ListMixin$(core.int), _internal.FixedLengthListMixin$(core.int)) {
@@ -15851,7 +15850,7 @@
set length(value) {
super.length = value;
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
this[index] = value;
return value;
@@ -15869,11 +15868,11 @@
dart.setSignature(_native_typed_data.NativeTypedArrayOfInt, {
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
- set: dart.definiteFunctionType(dart.void, [core.int, core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, core.int]),
setRange: dart.definiteFunctionType(dart.void, [core.int, core.int, IterableOfint()], [core.int])
})
});
- dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfInt, ['set', 'setRange', 'length']);
+ dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfInt, ['_set', 'setRange', 'length']);
dart.defineExtensionNames([
'runtimeType',
'sublist'
@@ -15976,7 +15975,7 @@
dart.registerExtension(dart.global.Float64Array, _native_typed_data.NativeFloat64List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeInt16List = class NativeInt16List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -15993,7 +15992,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Int16List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16021,7 +16020,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeInt16List, [_native_typed_data.NativeByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16034,7 +16033,7 @@
dart.registerExtension(dart.global.Int16Array, _native_typed_data.NativeInt16List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeInt32List = class NativeInt32List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16051,7 +16050,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Int32List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16079,7 +16078,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeInt32List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16092,7 +16091,7 @@
dart.registerExtension(dart.global.Int32Array, _native_typed_data.NativeInt32List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeInt8List = class NativeInt8List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16109,7 +16108,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Int8List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16137,7 +16136,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeInt8List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16150,7 +16149,7 @@
dart.registerExtension(dart.global.Int8Array, _native_typed_data.NativeInt8List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint16List = class NativeUint16List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16167,7 +16166,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Uint16List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16195,7 +16194,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint16List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16208,7 +16207,7 @@
dart.registerExtension(dart.global.Uint16Array, _native_typed_data.NativeUint16List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint32List = class NativeUint32List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16225,7 +16224,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Uint32List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16253,7 +16252,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint32List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16267,7 +16266,7 @@
dart.defineExtensionNames([
'runtimeType',
'length',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint8ClampedList = class NativeUint8ClampedList extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16290,7 +16289,7 @@
set [dartx.length](value) {
super[dartx.length] = value;
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16318,7 +16317,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint8ClampedList, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16333,7 +16332,7 @@
dart.defineExtensionNames([
'runtimeType',
'length',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint8List = class NativeUint8List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16356,7 +16355,7 @@
set [dartx.length](value) {
super[dartx.length] = value;
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16384,7 +16383,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint8List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16397,8 +16396,8 @@
dart.registerExtension(dart.global.Uint8Array, _native_typed_data.NativeUint8List);
_native_typed_data.NativeFloat32x4 = class NativeFloat32x4 extends core.Object {
static _truncate(x) {
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, core.num._check(x));
- return _native_typed_data.NativeFloat32x4._list[dartx.get](0);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, core.num._check(x));
+ return _native_typed_data.NativeFloat32x4._list[dartx._get](0);
}
new(x, y, z, w) {
this.x = core.double._check(_native_typed_data.NativeFloat32x4._truncate(x));
@@ -16417,11 +16416,11 @@
NativeFloat32x4.prototype._truncated.call(this, 0.0, 0.0, 0.0, 0.0);
}
static fromInt32x4Bits(i) {
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](0, i.x);
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](1, i.y);
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](2, i.z);
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](3, i.w);
- return new _native_typed_data.NativeFloat32x4._truncated(_native_typed_data.NativeFloat32x4._list[dartx.get](0), _native_typed_data.NativeFloat32x4._list[dartx.get](1), _native_typed_data.NativeFloat32x4._list[dartx.get](2), _native_typed_data.NativeFloat32x4._list[dartx.get](3));
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](0, i.x);
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](1, i.y);
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](2, i.z);
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](3, i.w);
+ return new _native_typed_data.NativeFloat32x4._truncated(_native_typed_data.NativeFloat32x4._list[dartx._get](0), _native_typed_data.NativeFloat32x4._list[dartx._get](1), _native_typed_data.NativeFloat32x4._list[dartx._get](2), _native_typed_data.NativeFloat32x4._list[dartx._get](3));
}
fromFloat64x2(v) {
NativeFloat32x4.prototype._truncated.call(this, core.double._check(_native_typed_data.NativeFloat32x4._truncate(v.x)), core.double._check(_native_typed_data.NativeFloat32x4._truncate(v.y)), 0.0, 0.0);
@@ -16448,7 +16447,7 @@
let _w = dart.notNull(this.w) + dart.notNull(other.w);
return new _native_typed_data.NativeFloat32x4._doubles(_x, _y, _z, _w);
}
- ['unary-']() {
+ _negate() {
return new _native_typed_data.NativeFloat32x4._truncated(-dart.notNull(this.x), -dart.notNull(this.y), -dart.notNull(this.z), -dart.notNull(this.w));
}
['-'](other) {
@@ -16554,46 +16553,46 @@
get signMask() {
let view = _native_typed_data.NativeFloat32x4._uint32view;
let mx = null, my = null, mz = null, mw = null;
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, this.w);
- mx = (dart.notNull(view[dartx.get](0)) & 2147483648) >>> 31;
- my = (dart.notNull(view[dartx.get](1)) & 2147483648) >>> 30;
- mz = (dart.notNull(view[dartx.get](2)) & 2147483648) >>> 29;
- mw = (dart.notNull(view[dartx.get](3)) & 2147483648) >>> 28;
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, this.w);
+ mx = (dart.notNull(view[dartx._get](0)) & 2147483648) >>> 31;
+ my = (dart.notNull(view[dartx._get](1)) & 2147483648) >>> 30;
+ mz = (dart.notNull(view[dartx._get](2)) & 2147483648) >>> 29;
+ mw = (dart.notNull(view[dartx._get](3)) & 2147483648) >>> 28;
return core.int._check(dart.dsend(dart.dsend(dart.dsend(mx, '|', my), '|', mz), '|', mw));
}
shuffle(mask) {
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- let _z = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ let _z = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
}
shuffleMix(other, mask) {
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, other.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, other.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, other.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, other.w);
- let _z = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, other.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, other.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, other.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, other.w);
+ let _z = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
}
withX(newX) {
@@ -16669,7 +16668,7 @@
getters: () => ({signMask: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
'+': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
- 'unary-': dart.definiteFunctionType(typed_data.Float32x4, []),
+ _negate: dart.definiteFunctionType(typed_data.Float32x4, []),
'-': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
'*': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
'/': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
@@ -16711,8 +16710,8 @@
});
_native_typed_data.NativeInt32x4 = class NativeInt32x4 extends core.Object {
static _truncate(x) {
- _native_typed_data.NativeInt32x4._list[dartx.set](0, core.int._check(x));
- return _native_typed_data.NativeInt32x4._list[dartx.get](0);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, core.int._check(x));
+ return _native_typed_data.NativeInt32x4._list[dartx._get](0);
}
new(x, y, z, w) {
this.x = core.int._check(_native_typed_data.NativeInt32x4._truncate(x));
@@ -16732,12 +16731,12 @@
}
static fromFloat32x4Bits(f) {
let floatList = _native_typed_data.NativeFloat32x4._list;
- floatList[dartx.set](0, f.x);
- floatList[dartx.set](1, f.y);
- floatList[dartx.set](2, f.z);
- floatList[dartx.set](3, f.w);
+ floatList[dartx._set](0, f.x);
+ floatList[dartx._set](1, f.y);
+ floatList[dartx._set](2, f.z);
+ floatList[dartx._set](3, f.w);
let view = _native_typed_data.NativeInt32List._check(floatList[dartx.buffer][dartx.asInt32List]());
- return new _native_typed_data.NativeInt32x4._truncated(view[dartx.get](0), view[dartx.get](1), view[dartx.get](2), view[dartx.get](3));
+ return new _native_typed_data.NativeInt32x4._truncated(view[dartx._get](0), view[dartx._get](1), view[dartx._get](2), view[dartx._get](3));
}
_truncated(x, y, z, w) {
this.x = x;
@@ -16763,7 +16762,7 @@
['-'](other) {
return new _native_typed_data.NativeInt32x4._truncated(this.x - other.x | 0, this.y - other.y | 0, this.z - other.z | 0, this.w - other.w | 0);
}
- ['unary-']() {
+ _negate() {
return new _native_typed_data.NativeInt32x4._truncated(-this.x | 0, -this.y | 0, -this.z | 0, -this.w | 0);
}
get signMask() {
@@ -16777,32 +16776,32 @@
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeInt32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeInt32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeInt32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeInt32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- let _z = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeInt32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeInt32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeInt32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ let _z = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
}
shuffleMix(other, mask) {
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeInt32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeInt32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeInt32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeInt32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- _native_typed_data.NativeInt32x4._list[dartx.set](0, other.x);
- _native_typed_data.NativeInt32x4._list[dartx.set](1, other.y);
- _native_typed_data.NativeInt32x4._list[dartx.set](2, other.z);
- _native_typed_data.NativeInt32x4._list[dartx.set](3, other.w);
- let _z = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeInt32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeInt32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeInt32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, other.x);
+ _native_typed_data.NativeInt32x4._list[dartx._set](1, other.y);
+ _native_typed_data.NativeInt32x4._list[dartx._set](2, other.z);
+ _native_typed_data.NativeInt32x4._list[dartx._set](3, other.w);
+ let _z = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
}
withX(x) {
@@ -16852,31 +16851,31 @@
select(trueValue, falseValue) {
let floatList = _native_typed_data.NativeFloat32x4._list;
let intView = _native_typed_data.NativeFloat32x4._uint32view;
- floatList[dartx.set](0, trueValue.x);
- floatList[dartx.set](1, trueValue.y);
- floatList[dartx.set](2, trueValue.z);
- floatList[dartx.set](3, trueValue.w);
- let stx = intView[dartx.get](0);
- let sty = intView[dartx.get](1);
- let stz = intView[dartx.get](2);
- let stw = intView[dartx.get](3);
- floatList[dartx.set](0, falseValue.x);
- floatList[dartx.set](1, falseValue.y);
- floatList[dartx.set](2, falseValue.z);
- floatList[dartx.set](3, falseValue.w);
- let sfx = intView[dartx.get](0);
- let sfy = intView[dartx.get](1);
- let sfz = intView[dartx.get](2);
- let sfw = intView[dartx.get](3);
+ floatList[dartx._set](0, trueValue.x);
+ floatList[dartx._set](1, trueValue.y);
+ floatList[dartx._set](2, trueValue.z);
+ floatList[dartx._set](3, trueValue.w);
+ let stx = intView[dartx._get](0);
+ let sty = intView[dartx._get](1);
+ let stz = intView[dartx._get](2);
+ let stw = intView[dartx._get](3);
+ floatList[dartx._set](0, falseValue.x);
+ floatList[dartx._set](1, falseValue.y);
+ floatList[dartx._set](2, falseValue.z);
+ floatList[dartx._set](3, falseValue.w);
+ let sfx = intView[dartx._get](0);
+ let sfy = intView[dartx._get](1);
+ let sfz = intView[dartx._get](2);
+ let sfw = intView[dartx._get](3);
let _x = (dart.notNull(this.x) & dart.notNull(stx) | ~dart.notNull(this.x) & dart.notNull(sfx)) >>> 0;
let _y = (dart.notNull(this.y) & dart.notNull(sty) | ~dart.notNull(this.y) & dart.notNull(sfy)) >>> 0;
let _z = (dart.notNull(this.z) & dart.notNull(stz) | ~dart.notNull(this.z) & dart.notNull(sfz)) >>> 0;
let _w = (dart.notNull(this.w) & dart.notNull(stw) | ~dart.notNull(this.w) & dart.notNull(sfw)) >>> 0;
- intView[dartx.set](0, _x);
- intView[dartx.set](1, _y);
- intView[dartx.set](2, _z);
- intView[dartx.set](3, _w);
- return new _native_typed_data.NativeFloat32x4._truncated(floatList[dartx.get](0), floatList[dartx.get](1), floatList[dartx.get](2), floatList[dartx.get](3));
+ intView[dartx._set](0, _x);
+ intView[dartx._set](1, _y);
+ intView[dartx._set](2, _z);
+ intView[dartx._set](3, _w);
+ return new _native_typed_data.NativeFloat32x4._truncated(floatList[dartx._get](0), floatList[dartx._get](1), floatList[dartx._get](2), floatList[dartx._get](3));
}
};
dart.defineNamedConstructor(_native_typed_data.NativeInt32x4, 'bool');
@@ -16908,7 +16907,7 @@
'^': dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4]),
'+': dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4]),
'-': dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4]),
- 'unary-': dart.definiteFunctionType(typed_data.Int32x4, []),
+ _negate: dart.definiteFunctionType(typed_data.Int32x4, []),
shuffle: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
shuffleMix: dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4, core.int]),
withX: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
@@ -16956,7 +16955,7 @@
['+'](other) {
return new _native_typed_data.NativeFloat64x2._doubles(dart.notNull(this.x) + dart.notNull(other.x), dart.notNull(this.y) + dart.notNull(other.y));
}
- ['unary-']() {
+ _negate() {
return new _native_typed_data.NativeFloat64x2._doubles(-dart.notNull(this.x), -dart.notNull(this.y));
}
['-'](other) {
@@ -16989,10 +16988,10 @@
}
get signMask() {
let view = _native_typed_data.NativeFloat64x2._uint32View;
- _native_typed_data.NativeFloat64x2._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat64x2._list[dartx.set](1, this.y);
- let mx = (dart.notNull(view[dartx.get](1)) & 2147483648) >>> 31;
- let my = (dart.notNull(view[dartx.get](3)) & 2147483648) >>> 31;
+ _native_typed_data.NativeFloat64x2._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat64x2._list[dartx._set](1, this.y);
+ let mx = (dart.notNull(view[dartx._get](1)) & 2147483648) >>> 31;
+ let my = (dart.notNull(view[dartx._get](3)) & 2147483648) >>> 31;
return (mx | my << 1) >>> 0;
}
withX(x) {
@@ -17033,7 +17032,7 @@
getters: () => ({signMask: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
'+': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
- 'unary-': dart.definiteFunctionType(typed_data.Float64x2, []),
+ _negate: dart.definiteFunctionType(typed_data.Float64x2, []),
'-': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
'*': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
'/': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
@@ -18400,7 +18399,7 @@
future.then(dart.dynamic)(dart.fn(value => {
remaining--;
if (values != null) {
- values[dartx.set](pos, value);
+ values[dartx._set](pos, value);
if (remaining == 0) {
result[_completeWithValue](values);
}
@@ -22425,13 +22424,13 @@
}
};
}
- get(key) {
- let result = this[_map$][dartx.get](key);
+ _get(key) {
+ let result = this[_map$][dartx._get](key);
if (result != null || dart.test(this[_map$][dartx.containsKey](key))) return result;
if (this.parent != null) {
- let value = this.parent.get(key);
+ let value = this.parent._get(key);
if (value != null) {
- this[_map$][dartx.set](key, value);
+ this[_map$][dartx._set](key, value);
}
return value;
}
@@ -22579,7 +22578,7 @@
bindCallback: dart.definiteFunctionType(R => [async.ZoneCallback$(R), [dart.functionType(R, [])], {runGuarded: core.bool}]),
bindUnaryCallback: dart.definiteFunctionType((R, T) => [async.ZoneUnaryCallback$(R, T), [dart.functionType(R, [T])], {runGuarded: core.bool}]),
bindBinaryCallback: dart.definiteFunctionType((R, T1, T2) => [async.ZoneBinaryCallback$(R, T1, T2), [dart.functionType(R, [T1, T2])], {runGuarded: core.bool}]),
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
handleUncaughtError: dart.definiteFunctionType(R => [R, [dart.dynamic, core.StackTrace]]),
fork: dart.definiteFunctionType(async.Zone, [], {specification: async.ZoneSpecification, zoneValues: core.Map}),
run: dart.definiteFunctionType(R => [R, [dart.functionType(R, [])]]),
@@ -22861,7 +22860,7 @@
}
};
}
- get(key) {
+ _get(key) {
return null;
}
handleUncaughtError(R) {
@@ -22951,7 +22950,7 @@
bindCallback: dart.definiteFunctionType(R => [async.ZoneCallback$(R), [dart.functionType(R, [])], {runGuarded: core.bool}]),
bindUnaryCallback: dart.definiteFunctionType((R, T) => [async.ZoneUnaryCallback$(R, T), [dart.functionType(R, [T])], {runGuarded: core.bool}]),
bindBinaryCallback: dart.definiteFunctionType((R, T1, T2) => [async.ZoneBinaryCallback$(R, T1, T2), [dart.functionType(R, [T1, T2])], {runGuarded: core.bool}]),
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
handleUncaughtError: dart.definiteFunctionType(R => [R, [dart.dynamic, core.StackTrace]]),
fork: dart.definiteFunctionType(async.Zone, [], {specification: async.ZoneSpecification, zoneValues: core.Map}),
run: dart.definiteFunctionType(R => [R, [dart.functionType(R, [])]]),
@@ -23065,7 +23064,7 @@
return new (_HashMapKeyIterableOfK())(this);
}
get values() {
- return MappedIterableOfK$V().new(this.keys, dart.fn(each => this.get(each), KToV()));
+ return MappedIterableOfK$V().new(this.keys, dart.fn(each => this._get(each), KToV()));
}
containsKey(key) {
if (dart.test(collection._HashMap._isStringKey(key))) {
@@ -23085,15 +23084,15 @@
return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
}
containsValue(value) {
- return this[_computeKeys]()[dartx.any](dart.fn(each => dart.equals(this.get(each), value), KTobool()));
+ return this[_computeKeys]()[dartx.any](dart.fn(each => dart.equals(this._get(each), value), KTobool()));
}
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
- get(key) {
+ _get(key) {
if (dart.test(collection._HashMap._isStringKey(key))) {
let strings = this[_strings$];
return V._check(strings == null ? null : collection._HashMap._getTableEntry(strings, key));
@@ -23111,7 +23110,7 @@
let index = this[_findBucketIndex](bucket, key);
return V._check(dart.notNull(index) < 0 ? null : bucket[dart.notNull(index) + 1]);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
if (dart.test(collection._HashMap._isStringKey(key))) {
@@ -23152,9 +23151,9 @@
putIfAbsent(key, ifAbsent) {
K._check(key);
VoidToV()._check(ifAbsent);
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
@@ -23186,7 +23185,7 @@
let keys = this[_computeKeys]();
for (let i = 0, length = keys[dartx.length]; i < dart.notNull(length); i++) {
let key = keys[i];
- action(K._check(key), this.get(key));
+ action(K._check(key), this._get(key));
if (keys !== this[_keys]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -23324,9 +23323,9 @@
[_containsKey]: dart.definiteFunctionType(core.bool, [core.Object]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
- get: dart.definiteFunctionType(V, [core.Object]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
[_get]: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
[_set]: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
remove: dart.definiteFunctionType(V, [core.Object]),
@@ -23355,8 +23354,8 @@
'containsKey',
'containsValue',
'addAll',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -23403,11 +23402,11 @@
this[_validKey] = validKey != null ? validKey : dart.fn(v => K.is(v), ObjectTobool());
super.new();
}
- get(key) {
+ _get(key) {
if (!dart.test(this[_validKey](key))) return null;
return super[_get](key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
super[_set](key, value);
@@ -23444,12 +23443,12 @@
[_validKey]: _PredicateOfObject()
}),
methods: () => ({
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
remove: dart.definiteFunctionType(V, [core.Object])
})
});
- dart.defineExtensionMembers(_CustomHashMap, ['get', 'set', 'containsKey', 'remove']);
+ dart.defineExtensionMembers(_CustomHashMap, ['_get', '_set', 'containsKey', 'remove']);
return _CustomHashMap;
});
collection._CustomHashMap = _CustomHashMap();
@@ -23626,13 +23625,13 @@
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
- get(key) {
+ _get(key) {
return this[_map$0].get(key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
this[_map$0].set(key, value);
@@ -23642,13 +23641,13 @@
putIfAbsent(key, ifAbsent) {
K._check(key);
VoidToV()._check(ifAbsent);
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
- let value = this.get(key);
+ let value = this._get(key);
this[_map$0].delete(key);
this[_modified$]();
return value;
@@ -23693,8 +23692,8 @@
}),
methods: () => ({
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
remove: dart.definiteFunctionType(V, [core.Object]),
forEach: dart.definiteFunctionType(dart.void, [KAndVTovoid()]),
@@ -23705,8 +23704,8 @@
'containsKey',
'containsValue',
'addAll',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -23852,11 +23851,11 @@
this[_validKey] = validKey != null ? validKey : dart.fn(v => K.is(v), ObjectTobool());
super.new();
}
- get(key) {
+ _get(key) {
if (!dart.test(this[_validKey](key))) return null;
return super.internalGet(key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
super.internalSet(key, value);
@@ -23891,12 +23890,12 @@
[_validKey]: _PredicateOfObject()
}),
methods: () => ({
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
remove: dart.definiteFunctionType(V, [core.Object])
})
});
- dart.defineExtensionMembers(_LinkedCustomHashMap, ['get', 'set', 'containsKey', 'remove']);
+ dart.defineExtensionMembers(_LinkedCustomHashMap, ['_get', '_set', 'containsKey', 'remove']);
return _LinkedCustomHashMap;
});
collection._LinkedCustomHashMap = _LinkedCustomHashMap();
@@ -23997,7 +23996,7 @@
})() : ListOfE().new(this.length);
let i = 0;
for (let element of this)
- result[dartx.set](i++, element);
+ result[dartx._set](i++, element);
return result;
}
map(T) {
@@ -24333,7 +24332,7 @@
let bucket = this[_getBucket$](rest, object);
let index = this[_findBucketIndex](bucket, object);
if (dart.notNull(index) < 0) return null;
- return bucket[dartx.get](index);
+ return bucket[dartx._get](index);
}
add(element) {
E._check(element);
@@ -24759,7 +24758,7 @@
let bucket = this[_getBucket$](rest, object);
let index = this[_findBucketIndex](bucket, object);
if (dart.notNull(index) < 0) return null;
- return bucket[dartx.get](index)[_element];
+ return bucket[dartx._get](index)[_element];
}
forEach(action) {
let cell = this[_first$];
@@ -25191,7 +25190,7 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
return this[_source$0][dartx.elementAt](index);
}
}
@@ -25199,9 +25198,9 @@
constructors: () => ({new: dart.definiteFunctionType(collection.UnmodifiableListView$(E), [IterableOfE()])}),
fields: () => ({[_source$0]: IterableOfE()}),
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
- methods: () => ({get: dart.definiteFunctionType(E, [core.int])})
+ methods: () => ({_get: dart.definiteFunctionType(E, [core.int])})
});
- dart.defineExtensionMembers(UnmodifiableListView, ['get', 'length']);
+ dart.defineExtensionMembers(UnmodifiableListView, ['_get', 'length']);
return UnmodifiableListView;
});
collection.UnmodifiableListView = UnmodifiableListView();
@@ -25270,7 +25269,7 @@
static from(other) {
let result = HashMapOfK$V().new();
other[dartx.forEach](dart.fn((k, v) => {
- result.set(K.as(k), V.as(v));
+ result._set(K.as(k), V.as(v));
}, dynamicAnddynamicTovoid$()));
return result;
}
@@ -25640,7 +25639,7 @@
});
collection._isToStringVisiting = function(o) {
for (let i = 0; i < dart.notNull(collection._toStringVisiting[dartx.length]); i++) {
- if (core.identical(o, collection._toStringVisiting[dartx.get](i))) return true;
+ if (core.identical(o, collection._toStringVisiting[dartx._get](i))) return true;
}
return false;
};
@@ -25822,7 +25821,7 @@
static from(other) {
let result = LinkedHashMapOfK$V().new();
other[dartx.forEach](dart.fn((k, v) => {
- result.set(K.as(k), V.as(v));
+ result._set(K.as(k), V.as(v));
}, dynamicAnddynamicTovoid$()));
return result;
}
@@ -26189,18 +26188,18 @@
class MapMixin extends core.Object {
forEach(action) {
for (let key of this.keys) {
- action(key, this.get(key));
+ action(key, this._get(key));
}
}
addAll(other) {
MapOfK$V()._check(other);
for (let key of other[dartx.keys]) {
- this.set(key, other[dartx.get](key));
+ this._set(key, other[dartx._get](key));
}
}
containsValue(value) {
for (let key of this.keys) {
- if (dart.equals(this.get(key), value)) return true;
+ if (dart.equals(this._get(key), value)) return true;
}
return false;
}
@@ -26208,9 +26207,9 @@
K._check(key);
VoidToV()._check(ifAbsent);
if (dart.test(this.containsKey(key))) {
- return this.get(key);
+ return this._get(key);
}
- return this.set(key, ifAbsent());
+ return this._set(key, ifAbsent());
}
containsKey(key) {
return this.keys[dartx.contains](key);
@@ -26271,7 +26270,7 @@
let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
let VoidToV = () => (VoidToV = dart.constFn(dart.functionType(V, [])))();
class _UnmodifiableMapMixin extends core.Object {
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
@@ -26297,7 +26296,7 @@
_UnmodifiableMapMixin[dart.implements] = () => [MapOfK$V()];
dart.setSignature(_UnmodifiableMapMixin, {
methods: () => ({
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
clear: dart.definiteFunctionType(dart.void, []),
remove: dart.definiteFunctionType(V, [core.Object]),
@@ -26305,7 +26304,7 @@
})
});
dart.defineExtensionMembers(_UnmodifiableMapMixin, [
- 'set',
+ '_set',
'addAll',
'clear',
'remove',
@@ -26341,13 +26340,13 @@
return this[_map$0][dartx.isNotEmpty];
}
get first() {
- return this[_map$0][dartx.get](this[_map$0][dartx.keys][dartx.first]);
+ return this[_map$0][dartx._get](this[_map$0][dartx.keys][dartx.first]);
}
get single() {
- return this[_map$0][dartx.get](this[_map$0][dartx.keys][dartx.single]);
+ return this[_map$0][dartx._get](this[_map$0][dartx.keys][dartx.single]);
}
get last() {
- return this[_map$0][dartx.get](this[_map$0][dartx.keys][dartx.last]);
+ return this[_map$0][dartx._get](this[_map$0][dartx.keys][dartx.last]);
}
get iterator() {
return new (_MapBaseValueIteratorOfK$V())(this[_map$0]);
@@ -26388,7 +26387,7 @@
}
moveNext() {
if (dart.test(this[_keys].moveNext())) {
- this[_current$2] = this[_map$0][dartx.get](this[_keys].current);
+ this[_current$2] = this[_map$0][dartx._get](this[_keys].current);
return true;
}
this[_current$2] = null;
@@ -26421,13 +26420,13 @@
new(map) {
this[_map$0] = map;
}
- get(key) {
- return this[_map$0][dartx.get](key);
+ _get(key) {
+ return this[_map$0][dartx._get](key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
- this[_map$0][dartx.set](key, value);
+ this[_map$0][dartx._set](key, value);
return value;
}
addAll(other) {
@@ -26486,8 +26485,8 @@
values: dart.definiteFunctionType(core.Iterable$(V), [])
}),
methods: () => ({
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
clear: dart.definiteFunctionType(dart.void, []),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
@@ -26498,8 +26497,8 @@
})
});
dart.defineExtensionMembers(MapView, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'addAll',
'clear',
'putIfAbsent',
@@ -26544,10 +26543,10 @@
}
static putIfAbsent(map, key, ifAbsent) {
if (dart.test(map[dartx.containsKey](key))) {
- return map[dartx.get](key);
+ return map[dartx._get](key);
}
let v = ifAbsent();
- map[dartx.set](key, v);
+ map[dartx._set](key, v);
return v;
}
static clear(map) {
@@ -26557,11 +26556,11 @@
}
static forEach(map, f) {
for (let k of map[dartx.keys]) {
- dart.dcall(f, k, map[dartx.get](k));
+ dart.dcall(f, k, map[dartx._get](k));
}
}
static getValues(map) {
- return map[dartx.keys][dartx.map](dart.dynamic)(dart.fn(key => map[dartx.get](key), dynamicTodynamic$()));
+ return map[dartx.keys][dartx.map](dart.dynamic)(dart.fn(key => map[dartx._get](key), dynamicTodynamic$()));
}
static length(map) {
return map[dartx.keys][dartx.length];
@@ -26604,7 +26603,7 @@
if (key == null) key = collection.Maps._id;
if (value == null) value = collection.Maps._id;
for (let element of iterable) {
- map[dartx.set](dart.dcall(key, element), dart.dcall(value, element));
+ map[dartx._set](dart.dcall(key, element), dart.dcall(value, element));
}
}
static _fillMapWithIterables(map, keys, values) {
@@ -26613,7 +26612,7 @@
let hasNextKey = keyIterator.moveNext();
let hasNextValue = valueIterator.moveNext();
while (dart.test(hasNextKey) && dart.test(hasNextValue)) {
- map[dartx.set](keyIterator.current, valueIterator.current);
+ map[dartx._set](keyIterator.current, valueIterator.current);
hasNextKey = keyIterator.moveNext();
hasNextValue = valueIterator.moveNext();
}
@@ -27152,7 +27151,7 @@
let queue = new (ListQueueOfE())(dart.notNull(length) + 1);
dart.assert(dart.notNull(queue[_table][dartx.length]) > dart.notNull(length));
for (let i = 0; i < dart.notNull(length); i++) {
- queue[_table][dartx.set](i, E.as(elements[dartx.get](i)));
+ queue[_table][dartx._set](i, E.as(elements[dartx._get](i)));
}
queue[_tail] = length;
return queue;
@@ -27174,7 +27173,7 @@
forEach(action) {
let modificationCount = this[_modificationCount];
for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0) {
- action(this[_table][dartx.get](i));
+ action(this[_table][dartx._get](i));
this[_checkModification](modificationCount);
}
}
@@ -27186,20 +27185,20 @@
}
get first() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
- return this[_table][dartx.get](this[_head]);
+ return this[_table][dartx._get](this[_head]);
}
get last() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
- return this[_table][dartx.get]((dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
+ return this[_table][dartx._get]((dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
}
get single() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
if (dart.notNull(this.length) > 1) dart.throw(_internal.IterableElementError.tooMany());
- return this[_table][dartx.get](this[_head]);
+ return this[_table][dartx._get](this[_head]);
}
elementAt(index) {
core.RangeError.checkValidIndex(index, this);
- return this[_table][dartx.get]((dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
+ return this[_table][dartx._get]((dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
}
toList(opts) {
let growable = opts && 'growable' in opts ? opts.growable : true;
@@ -27247,7 +27246,7 @@
}
remove(value) {
for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0) {
- let element = this[_table][dartx.get](i);
+ let element = this[_table][dartx._get](i);
if (dart.equals(element, value)) {
this[_remove](i);
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ -27260,7 +27259,7 @@
let modificationCount = this[_modificationCount];
let i = this[_head];
while (i != this[_tail]) {
- let element = this[_table][dartx.get](i);
+ let element = this[_table][dartx._get](i);
let remove = core.identical(removeMatching, test(element));
this[_checkModification](modificationCount);
if (remove) {
@@ -27280,7 +27279,7 @@
clear() {
if (this[_head] != this[_tail]) {
for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0) {
- this[_table][dartx.set](i, null);
+ this[_table][dartx._set](i, null);
}
this[_head] = this[_tail] = 0;
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ -27296,15 +27295,15 @@
addFirst(value) {
E._check(value);
this[_head] = (dart.notNull(this[_head]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
- this[_table][dartx.set](this[_head], value);
+ this[_table][dartx._set](this[_head], value);
if (this[_head] == this[_tail]) this[_grow]();
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
}
removeFirst() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
- let result = this[_table][dartx.get](this[_head]);
- this[_table][dartx.set](this[_head], null);
+ let result = this[_table][dartx._get](this[_head]);
+ this[_table][dartx._set](this[_head], null);
this[_head] = (dart.notNull(this[_head]) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
return result;
}
@@ -27312,8 +27311,8 @@
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
this[_tail] = (dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
- let result = this[_table][dartx.get](this[_tail]);
- this[_table][dartx.set](this[_tail], null);
+ let result = this[_table][dartx._get](this[_tail]);
+ this[_table][dartx._set](this[_tail], null);
return result;
}
static _isPowerOf2(number) {
@@ -27335,7 +27334,7 @@
}
[_add$0](element) {
E._check(element);
- this[_table][dartx.set](this[_tail], element);
+ this[_table][dartx._set](this[_tail], element);
this[_tail] = (dart.notNull(this[_tail]) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
if (this[_head] == this[_tail]) this[_grow]();
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ -27348,10 +27347,10 @@
let i = offset;
while (i != this[_head]) {
let prevOffset = (dart.notNull(i) - 1 & mask) >>> 0;
- this[_table][dartx.set](i, this[_table][dartx.get](prevOffset));
+ this[_table][dartx._set](i, this[_table][dartx._get](prevOffset));
i = prevOffset;
}
- this[_table][dartx.set](this[_head], null);
+ this[_table][dartx._set](this[_head], null);
this[_head] = (dart.notNull(this[_head]) + 1 & mask) >>> 0;
return (dart.notNull(offset) + 1 & mask) >>> 0;
} else {
@@ -27359,10 +27358,10 @@
let i = offset;
while (i != this[_tail]) {
let nextOffset = (dart.notNull(i) + 1 & mask) >>> 0;
- this[_table][dartx.set](i, this[_table][dartx.get](nextOffset));
+ this[_table][dartx._set](i, this[_table][dartx._get](nextOffset));
i = nextOffset;
}
- this[_table][dartx.set](this[_tail], null);
+ this[_table][dartx._set](this[_tail], null);
return offset;
}
}
@@ -27484,7 +27483,7 @@
this[_current$2] = null;
return false;
}
- this[_current$2] = this[_queue][_table][dartx.get](this[_position]);
+ this[_current$2] = this[_queue][_table][dartx._get](this[_position]);
this[_position] = (dart.notNull(this[_position]) + 1 & dart.notNull(this[_queue][_table][dartx.length]) - 1) >>> 0;
return true;
}
@@ -27759,7 +27758,7 @@
if (isValidKey === void 0) isValidKey = null;
let result = new (SplayTreeMapOfK$V())(compare, isValidKey);
other[dartx.forEach](dart.fn((k, v) => {
- result.set(K.as(k), V.as(v));
+ result._set(K.as(k), V.as(v));
}, dynamicAnddynamicTovoid$()));
return result;
}
@@ -27791,7 +27790,7 @@
this[_validKey] = null;
super.new();
}
- get(key) {
+ _get(key) {
if (!dart.test(dart.dcall(this[_validKey], key))) return null;
if (this[_root] != null) {
let comp = this[_splay](K.as(key));
@@ -27807,7 +27806,7 @@
if (mapRoot != null) return mapRoot.value;
return null;
}
- set(key, value) {
+ _set(key, value) {
(() => {
K._check(key);
V._check(value);
@@ -27845,7 +27844,7 @@
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
get isEmpty() {
@@ -27956,9 +27955,9 @@
}),
methods: () => ({
[_compare]: dart.definiteFunctionType(core.int, [K, K]),
- get: dart.definiteFunctionType(V, [core.Object]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
remove: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
forEach: dart.definiteFunctionType(dart.void, [KAndVTovoid()]),
@@ -27972,9 +27971,9 @@
})
});
dart.defineExtensionMembers(SplayTreeMap, [
- 'get',
+ '_get',
'remove',
- 'set',
+ '_set',
'putIfAbsent',
'addAll',
'forEach',
@@ -28449,7 +28448,7 @@
let processed = map[_processed];
let keys = map[_computeKeys$]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
+ let key = keys[dartx._get](i);
let revived = dart.dcall(reviver, key, walk(e[key]));
processed[key] = revived;
}
@@ -28486,9 +28485,9 @@
this[_original] = original;
this[_data] = null;
}
- get(key) {
+ _get(key) {
if (dart.test(this[_isUpgraded])) {
- return this[_upgradedMap][dartx.get](key);
+ return this[_upgradedMap][dartx._get](key);
} else if (!(typeof key == 'string')) {
return null;
} else {
@@ -28512,11 +28511,11 @@
}
get values() {
if (dart.test(this[_isUpgraded])) return this[_upgradedMap][dartx.values];
- return MappedIterableOfString$dynamic().new(this[_computeKeys$](), dart.fn(each => this.get(each), dynamicTodynamic$()));
+ return MappedIterableOfString$dynamic().new(this[_computeKeys$](), dart.fn(each => this._get(each), dynamicTodynamic$()));
}
- set(key, value) {
+ _set(key, value) {
if (dart.test(this[_isUpgraded])) {
- this[_upgradedMap][dartx.set](key, value);
+ this[_upgradedMap][dartx._set](key, value);
} else if (dart.test(this.containsKey(key))) {
let processed = this[_processed];
convert._JsonMap._setProperty(processed, core.String._check(key), value);
@@ -28525,21 +28524,21 @@
convert._JsonMap._setProperty(original, core.String._check(key), null);
}
} else {
- this[_upgrade]()[dartx.set](key, value);
+ this[_upgrade]()[dartx._set](key, value);
}
return value;
}
addAll(other) {
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, dynamicAnddynamicTovoid$()));
}
containsValue(value) {
if (dart.test(this[_isUpgraded])) return this[_upgradedMap][dartx.containsValue](value);
let keys = this[_computeKeys$]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
- if (dart.equals(this.get(key), value)) return true;
+ let key = keys[dartx._get](i);
+ if (dart.equals(this._get(key), value)) return true;
}
return false;
}
@@ -28549,9 +28548,9 @@
return convert._JsonMap._hasProperty(this[_original], core.String._check(key));
}
putIfAbsent(key, ifAbsent) {
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
@@ -28573,7 +28572,7 @@
if (dart.test(this[_isUpgraded])) return this[_upgradedMap][dartx.forEach](f);
let keys = this[_computeKeys$]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
+ let key = keys[dartx._get](i);
let value = convert._JsonMap._getProperty(this[_processed], key);
if (dart.test(convert._JsonMap._isUnprocessed(value))) {
value = convert._convertJsonToDartLazy(convert._JsonMap._getProperty(this[_original], key));
@@ -28608,8 +28607,8 @@
let result = dart.map();
let keys = this[_computeKeys$]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
- result[dartx.set](key, this.get(key));
+ let key = keys[dartx._get](i);
+ result[dartx._set](key, this._get(key));
}
if (dart.test(keys[dartx.isEmpty])) {
keys[dartx.add](null);
@@ -28663,8 +28662,8 @@
[_upgradedMap]: dart.definiteFunctionType(core.Map, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic]),
addAll: dart.definiteFunctionType(dart.void, [core.Map]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
@@ -28687,8 +28686,8 @@
names: ['_hasProperty', '_getProperty', '_setProperty', '_getPropertyNames', '_isUnprocessed', '_newJavaScriptObject']
});
dart.defineExtensionMembers(convert._JsonMap, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'addAll',
'containsValue',
'containsKey',
@@ -28712,7 +28711,7 @@
return this[_parent].length;
}
elementAt(index) {
- return core.String._check(dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.elementAt](index) : this[_parent][_computeKeys$]()[dartx.get](index));
+ return core.String._check(dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.elementAt](index) : this[_parent][_computeKeys$]()[dartx._get](index));
}
get iterator() {
return dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.iterator] : this[_parent][_computeKeys$]()[dartx.iterator];
@@ -28956,7 +28955,7 @@
let result = ListOfE().new(length);
if (length != 0 && fill != null) {
for (let i = 0; i < dart.notNull(result[dartx.length]); i++) {
- result[dartx.set](i, fill);
+ result[dartx._set](i, fill);
}
}
return result;
@@ -28980,7 +28979,7 @@
result = ListOfE().new(length);
}
for (let i = 0; i < dart.notNull(length); i++) {
- result[dartx.set](i, generator(i));
+ result[dartx._set](i, generator(i));
}
return result;
}
@@ -29019,7 +29018,7 @@
static getByName(name) {
if (name == null) return null;
name = name[dartx.toLowerCase]();
- return convert.Encoding._nameToEncoding[dartx.get](name);
+ return convert.Encoding._nameToEncoding[dartx._get](name);
}
};
dart.addSimpleTypeTests(convert.Encoding);
@@ -29130,7 +29129,7 @@
if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) != 0) {
dart.throw(new core.ArgumentError("String contains invalid characters."));
}
- result[dartx.set](i, codeUnit);
+ result[dartx._set](i, codeUnit);
}
return result;
}
@@ -29209,7 +29208,7 @@
core.RangeError.checkValidRange(start, end, byteCount);
if (end == null) end = byteCount;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
if ((dart.notNull(byte) & ~dart.notNull(this[_subsetMask])) != 0) {
if (!dart.test(this[_allowInvalid])) {
dart.throw(new core.FormatException(dart.str`Invalid value in input: ${byte}`));
@@ -29222,7 +29221,7 @@
[_convertInvalid](bytes, start, end) {
let buffer = new core.StringBuffer();
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let value = bytes[dartx.get](i);
+ let value = bytes[dartx._get](i);
if ((dart.notNull(value) & ~dart.notNull(this[_subsetMask])) != 0) value = 65533;
buffer.writeCharCode(value);
}
@@ -29338,7 +29337,7 @@
addSlice(source, start, end, isLast) {
core.RangeError.checkValidRange(start, end, source[dartx.length]);
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- if ((dart.notNull(source[dartx.get](i)) & ~convert._ASCII_MASK) != 0) {
+ if ((dart.notNull(source[dartx._get](i)) & ~convert._ASCII_MASK) != 0) {
if (dart.notNull(i) > dart.notNull(start)) this[_utf8Sink].addSlice(source, start, i, false);
this[_utf8Sink].add(const$30 || (const$30 = dart.constList([239, 191, 189], core.int)));
start = dart.notNull(i) + 1;
@@ -29369,7 +29368,7 @@
}
add(source) {
for (let i = 0; i < dart.notNull(source[dartx.length]); i++) {
- if ((dart.notNull(source[dartx.get](i)) & ~convert._ASCII_MASK) != 0) {
+ if ((dart.notNull(source[dartx._get](i)) & ~convert._ASCII_MASK) != 0) {
dart.throw(new core.FormatException("Source contains non-ASCII bytes."));
}
}
@@ -29510,27 +29509,27 @@
let expectedChars = 3 - dart.notNull(convert._Base64Encoder._stateCount(state));
let byteOr = 0;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
byteOr = (dart.notNull(byteOr) | dart.notNull(byte)) >>> 0;
bits = (dart.notNull(bits) << 8 | dart.notNull(byte)) & 16777215;
expectedChars--;
if (expectedChars == 0) {
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 18 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 12 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 6 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
@@ -29548,53 +29547,53 @@
}
let i = start;
while (dart.notNull(i) < dart.notNull(end)) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) break;
i = dart.notNull(i) + 1;
}
- dart.throw(new core.ArgumentError.value(bytes, dart.str`Not a byte value at index ${i}: 0x${bytes[dartx.get](i)[dartx.toRadixString](16)}`));
+ dart.throw(new core.ArgumentError.value(bytes, dart.str`Not a byte value at index ${i}: 0x${bytes[dartx._get](i)[dartx.toRadixString](16)}`));
}
static writeFinalChunk(alphabet, output, outputIndex, count, bits) {
dart.assert(dart.notNull(count) > 0);
if (count == 1) {
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 2 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) << 4 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), convert._paddingChar);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), convert._paddingChar);
} else {
dart.assert(count == 2);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 10 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 4 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) << 2 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
@@ -29806,23 +29805,23 @@
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
let char = input[dartx.codeUnitAt](i);
charOr = (dart.notNull(charOr) | dart.notNull(char)) >>> 0;
- let code = convert._Base64Decoder._inverseAlphabet[dartx.get]((dart.notNull(char) & asciiMask) >>> 0);
+ let code = convert._Base64Decoder._inverseAlphabet[dartx._get]((dart.notNull(char) & asciiMask) >>> 0);
if (dart.notNull(code) >= 0) {
bits = (bits[dartx['<<']](bitsPerCharacter) | dart.notNull(code)) & 16777215;
count = dart.notNull(count) + 1 & 3;
if (count == 0) {
dart.assert(dart.notNull(outIndex) + 3 <= dart.notNull(output[dartx.length]));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
})(), (bits[dartx['>>']](16) & eightBitMask) >>> 0);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
})(), (bits[dartx['>>']](8) & eightBitMask) >>> 0);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
@@ -29836,12 +29835,12 @@
if ((dart.notNull(bits) & 3) != 0) {
dart.throw(new core.FormatException("Invalid encoding before padding", input, i));
}
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
})(), bits[dartx['>>']](10));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
@@ -29850,7 +29849,7 @@
if ((dart.notNull(bits) & 15) != 0) {
dart.throw(new core.FormatException("Invalid encoding before padding", input, i));
}
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
@@ -30402,7 +30401,7 @@
[_convert](text, start, end) {
let result = null;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let ch = text[dartx.get](i);
+ let ch = text[dartx._get](i);
let replacement = null;
switch (ch) {
case '&':
@@ -30674,14 +30673,14 @@
}
dart.fn(addChunk, Uint8ListAndintAndintTovoid$());
convert._JsonUtf8Stringifier.stringify(object, this[_indent], this[_toEncodable], this[_bufferSize], addChunk);
- if (bytes[dartx.length] == 1) return bytes[dartx.get](0);
+ if (bytes[dartx.length] == 1) return bytes[dartx._get](0);
let length = 0;
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- length = dart.notNull(length) + dart.notNull(bytes[dartx.get](i)[dartx.length]);
+ length = dart.notNull(length) + dart.notNull(bytes[dartx._get](i)[dartx.length]);
}
let result = typed_data.Uint8List.new(length);
for (let i = 0, offset = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byteList = bytes[dartx.get](i);
+ let byteList = bytes[dartx._get](i);
let end = offset + dart.notNull(byteList[dartx.length]);
result[dartx.setRange](offset, end, byteList);
offset = end;
@@ -30918,7 +30917,7 @@
}
[_checkCycle](object) {
for (let i = 0; i < dart.notNull(this[_seen][dartx.length]); i++) {
- if (core.identical(object, this[_seen][dartx.get](i))) {
+ if (core.identical(object, this[_seen][dartx._get](i))) {
dart.throw(new convert.JsonCyclicError(object));
}
}
@@ -30979,10 +30978,10 @@
writeList(list) {
this.writeString('[');
if (dart.notNull(list[dartx.length]) > 0) {
- this.writeObject(list[dartx.get](0));
+ this.writeObject(list[dartx._get](0));
for (let i = 1; i < dart.notNull(list[dartx.length]); i++) {
this.writeString(',');
- this.writeObject(list[dartx.get](i));
+ this.writeObject(list[dartx._get](i));
}
}
this.writeString(']');
@@ -30999,8 +30998,8 @@
if (!(typeof key == 'string')) {
allStringKeys = false;
}
- keyValueList[dartx.set](i++, key);
- keyValueList[dartx.set](i++, value);
+ keyValueList[dartx._set](i++, key);
+ keyValueList[dartx._set](i++, value);
}, dynamicAnddynamicTovoid$()));
if (!allStringKeys) return false;
this.writeString('{');
@@ -31008,9 +31007,9 @@
for (let i = 0; i < dart.notNull(keyValueList[dartx.length]); i = i + 2) {
this.writeString(separator);
separator = ',"';
- this.writeStringContent(core.String._check(keyValueList[dartx.get](i)));
+ this.writeStringContent(core.String._check(keyValueList[dartx._get](i)));
this.writeString('":');
- this.writeObject(keyValueList[dartx.get](i + 1));
+ this.writeObject(keyValueList[dartx._get](i + 1));
}
this.writeString('}');
return true;
@@ -31076,11 +31075,11 @@
this.writeString('[\n');
this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
this.writeIndentation(this[_indentLevel]);
- this.writeObject(list[dartx.get](0));
+ this.writeObject(list[dartx._get](0));
for (let i = 1; i < dart.notNull(list[dartx.length]); i++) {
this.writeString(',\n');
this.writeIndentation(this[_indentLevel]);
- this.writeObject(list[dartx.get](i));
+ this.writeObject(list[dartx._get](i));
}
this.writeString('\n');
this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
@@ -31100,8 +31099,8 @@
if (!(typeof key == 'string')) {
allStringKeys = false;
}
- keyValueList[dartx.set](i++, key);
- keyValueList[dartx.set](i++, value);
+ keyValueList[dartx._set](i++, key);
+ keyValueList[dartx._set](i++, value);
}, dynamicAnddynamicTovoid$()));
if (!allStringKeys) return false;
this.writeString('{\n');
@@ -31112,9 +31111,9 @@
separator = ",\n";
this.writeIndentation(this[_indentLevel]);
this.writeString('"');
- this.writeStringContent(core.String._check(keyValueList[dartx.get](i)));
+ this.writeStringContent(core.String._check(keyValueList[dartx._get](i)));
this.writeString('": ');
- this.writeObject(keyValueList[dartx.get](i + 1));
+ this.writeObject(keyValueList[dartx._get](i + 1));
}
this.writeString('\n');
this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
@@ -31286,7 +31285,7 @@
this.buffer = typed_data.Uint8List.new(this.bufferSize);
this.index = 0;
}
- this.buffer[dartx.set]((() => {
+ this.buffer[dartx._set]((() => {
let x = this.index;
this.index = dart.notNull(x) + 1;
return x;
@@ -31324,7 +31323,7 @@
let indent = this.indent;
let indentLength = indent[dartx.length];
if (indentLength == 1) {
- let char = indent[dartx.get](0);
+ let char = indent[dartx._get](0);
while (dart.notNull(count) > 0) {
this.writeByte(char);
count = dart.notNull(count) - 1;
@@ -31339,7 +31338,7 @@
this.index = end;
} else {
for (let i = 0; i < dart.notNull(indentLength); i++) {
- this.writeByte(indent[dartx.get](i));
+ this.writeByte(indent[dartx._get](i));
}
}
}
@@ -31448,7 +31447,7 @@
static _checkValidLatin1(source, start, end) {
let mask = 0;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- mask = (dart.notNull(mask) | dart.notNull(source[dartx.get](i))) >>> 0;
+ mask = (dart.notNull(mask) | dart.notNull(source[dartx._get](i))) >>> 0;
}
if (dart.notNull(mask) >= 0 && dart.notNull(mask) <= convert._LATIN1_MASK) {
return;
@@ -31457,7 +31456,7 @@
}
static _reportInvalidLatin1(source, start, end) {
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let char = source[dartx.get](i);
+ let char = source[dartx._get](i);
if (dart.notNull(char) < 0 || dart.notNull(char) > convert._LATIN1_MASK) {
dart.throw(new core.FormatException("Source contains non-Latin-1 characters.", source, i));
}
@@ -31487,7 +31486,7 @@
addSlice(source, start, end, isLast) {
core.RangeError.checkValidRange(start, end, source[dartx.length]);
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let char = source[dartx.get](i);
+ let char = source[dartx._get](i);
if (dart.notNull(char) > convert._LATIN1_MASK || dart.notNull(char) < 0) {
if (dart.notNull(i) > dart.notNull(start)) this[_addSliceToSink](source, start, i, false);
this[_addSliceToSink](const$49 || (const$49 = dart.constList([65533], core.int)), 0, 1, false);
@@ -32027,39 +32026,39 @@
let rune = convert._combineSurrogatePair(leadingSurrogate, nextCodeUnit);
dart.assert(dart.notNull(rune) > convert._THREE_BYTE_LIMIT);
dart.assert(dart.notNull(rune) <= convert._FOUR_BYTE_LIMIT);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (240 | rune[dartx['>>']](18)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) >> 12 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) >> 6 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) & 63);
return true;
} else {
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (224 | leadingSurrogate[dartx['>>']](12)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(leadingSurrogate) >> 6 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32076,7 +32075,7 @@
let codeUnit = str[dartx.codeUnitAt](stringIndex);
if (dart.notNull(codeUnit) <= convert._ONE_BYTE_LIMIT) {
if (dart.notNull(this[_bufferIndex]) >= dart.notNull(this[_buffer][dartx.length])) break;
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32092,12 +32091,12 @@
let rune = codeUnit;
if (dart.notNull(rune) <= convert._TWO_BYTE_LIMIT) {
if (dart.notNull(this[_bufferIndex]) + 1 >= dart.notNull(this[_buffer][dartx.length])) break;
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (192 | rune[dartx['>>']](6)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32105,17 +32104,17 @@
} else {
dart.assert(dart.notNull(rune) <= convert._THREE_BYTE_LIMIT);
if (dart.notNull(this[_bufferIndex]) + 2 >= dart.notNull(this[_buffer][dartx.length])) break;
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (224 | rune[dartx['>>']](12)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) >> 6 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32342,7 +32341,7 @@
if (i == endIndex) {
break loop;
}
- let unit = codeUnits[dartx.get](i);
+ let unit = codeUnits[dartx._get](i);
if ((dart.notNull(unit) & 192) != 128) {
expectedUnits = 0;
if (!dart.test(this[_allowMalformed])) {
@@ -32357,7 +32356,7 @@
i = dart.notNull(i) + 1;
}
} while (dart.notNull(expectedUnits) > 0);
- if (dart.notNull(value) <= dart.notNull(convert._Utf8Decoder._LIMITS[dartx.get](dart.notNull(extraUnits) - 1))) {
+ if (dart.notNull(value) <= dart.notNull(convert._Utf8Decoder._LIMITS[dartx._get](dart.notNull(extraUnits) - 1))) {
if (!dart.test(this[_allowMalformed])) {
dart.throw(new core.FormatException(dart.str`Overlong encoding of 0x${value[dartx.toRadixString](16)}`));
}
@@ -32383,7 +32382,7 @@
i = dart.notNull(i) + dart.notNull(oneBytes);
if (i == endIndex) break;
}
- let unit = codeUnits[dartx.get]((() => {
+ let unit = codeUnits[dartx._get]((() => {
let x = i;
i = dart.notNull(x) + 1;
return x;
@@ -32579,23 +32578,23 @@
return result;
}
dart.fn(parseMilliAndMicroseconds, StringToint$());
- let years = core.int.parse(match.get(1));
- let month = core.int.parse(match.get(2));
- let day = core.int.parse(match.get(3));
- let hour = parseIntOrZero(match.get(4));
- let minute = parseIntOrZero(match.get(5));
- let second = parseIntOrZero(match.get(6));
+ let years = core.int.parse(match._get(1));
+ let month = core.int.parse(match._get(2));
+ let day = core.int.parse(match._get(3));
+ let hour = parseIntOrZero(match._get(4));
+ let minute = parseIntOrZero(match._get(5));
+ let second = parseIntOrZero(match._get(6));
let addOneMillisecond = false;
- let milliAndMicroseconds = parseMilliAndMicroseconds(match.get(7));
+ let milliAndMicroseconds = parseMilliAndMicroseconds(match._get(7));
let millisecond = (dart.notNull(milliAndMicroseconds) / core.Duration.MICROSECONDS_PER_MILLISECOND)[dartx.truncate]();
let microsecond = dart.asInt(milliAndMicroseconds[dartx.remainder](core.Duration.MICROSECONDS_PER_MILLISECOND));
let isUtc = false;
- if (match.get(8) != null) {
+ if (match._get(8) != null) {
isUtc = true;
- if (match.get(9) != null) {
- let sign = match.get(9) == '-' ? -1 : 1;
- let hourDifference = core.int.parse(match.get(10));
- let minuteDifference = parseIntOrZero(match.get(11));
+ if (match._get(9) != null) {
+ let sign = match._get(9) == '-' ? -1 : 1;
+ let hourDifference = core.int.parse(match._get(10));
+ let minuteDifference = parseIntOrZero(match._get(11));
minuteDifference = dart.notNull(minuteDifference) + 60 * dart.notNull(hourDifference);
minute = dart.notNull(minute) - sign * dart.notNull(minuteDifference);
}
@@ -32965,7 +32964,7 @@
}
dart.fn(twoDigits, intToString());
if (dart.notNull(this.inMicroseconds) < 0) {
- return dart.str`-${this['unary-']()}`;
+ return dart.str`-${this._negate()}`;
}
let twoDigitMinutes = twoDigits(dart.asInt(this.inMinutes[dartx.remainder](core.Duration.MINUTES_PER_HOUR)));
let twoDigitSeconds = twoDigits(dart.asInt(this.inSeconds[dartx.remainder](core.Duration.SECONDS_PER_MINUTE)));
@@ -32978,7 +32977,7 @@
abs() {
return new core.Duration._microseconds(this[_duration][dartx.abs]());
}
- ['unary-']() {
+ _negate() {
return new core.Duration._microseconds(-dart.notNull(this[_duration]));
}
};
@@ -33010,7 +33009,7 @@
'>=': dart.definiteFunctionType(core.bool, [core.Duration]),
compareTo: dart.definiteFunctionType(core.int, [core.Duration]),
abs: dart.definiteFunctionType(core.Duration, []),
- 'unary-': dart.definiteFunctionType(core.Duration, [])
+ _negate: dart.definiteFunctionType(core.Duration, [])
}),
sfields: () => ({
MICROSECONDS_PER_MILLISECOND: core.int,
@@ -33340,7 +33339,7 @@
if (i > 0) {
sb.write(", ");
}
- sb.write(core.Error.safeToString(this[_arguments][dartx.get](i)));
+ sb.write(core.Error.safeToString(this[_arguments][dartx._get](i)));
}
}
if (this[_namedArguments] != null) {
@@ -33363,7 +33362,7 @@
if (i > 0) {
sb.write(", ");
}
- sb.write(this[_existingArgumentNames][dartx.get](i));
+ sb.write(this[_existingArgumentNames][dartx._get](i));
}
let formalParameters = sb.toString();
return "NoSuchMethodError: incorrect number of arguments passed to " + dart.str`method named '${this[_memberName]}'\n` + dart.str`Receiver: ${core.Error.safeToString(this[_receiver$])}\n` + dart.str`Tried calling: ${this[_memberName]}(${actualParameters})\n` + dart.str`Found: ${this[_memberName]}(${formalParameters})`;
@@ -33621,11 +33620,11 @@
toString() {
return dart.str`Expando:${this.name}`;
}
- get(object) {
+ _get(object) {
let values = _js_helper.Primitives.getProperty(object, core.Expando._EXPANDO_PROPERTY_NAME);
return T._check(values == null ? null : _js_helper.Primitives.getProperty(values, this[_getKey]()));
}
- set(object, value) {
+ _set(object, value) {
T._check(value);
let values = _js_helper.Primitives.getProperty(object, core.Expando._EXPANDO_PROPERTY_NAME);
if (values == null) {
@@ -33653,8 +33652,8 @@
constructors: () => ({new: dart.definiteFunctionType(core.Expando$(T), [], [core.String])}),
fields: () => ({name: core.String}),
methods: () => ({
- get: dart.definiteFunctionType(T, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.Object, T]),
+ _get: dart.definiteFunctionType(T, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.Object, T]),
[_getKey]: dart.definiteFunctionType(core.String, [])
}),
sfields: () => ({
@@ -33677,7 +33676,7 @@
static _toMangledNames(namedArguments) {
let result = dart.map({}, core.String, dart.dynamic);
namedArguments[dartx.forEach](dart.fn((symbol, value) => {
- result[dartx.set](core._symbolToString(symbol), value);
+ result[dartx._set](core._symbolToString(symbol), value);
}, SymbolAnddynamicTovoid()));
return result;
}
@@ -34155,7 +34154,7 @@
}
get currentAsString() {
if (this[_position$] == this[_nextPosition]) return null;
- if (dart.notNull(this[_position$]) + 1 == this[_nextPosition]) return this.string[dartx.get](this[_position$]);
+ if (dart.notNull(this[_position$]) + 1 == this[_nextPosition]) return this.string[dartx._get](this[_position$]);
return this.string[dartx.substring](this[_position$], this[_nextPosition]);
}
moveNext() {
@@ -34843,7 +34842,7 @@
if (this[_queryParameterLists] == null) {
let queryParameterLists = core.Uri._splitQueryStringAll(this.query);
for (let key of queryParameterLists[dartx.keys]) {
- queryParameterLists[dartx.set](key, ListOfString().unmodifiable(core.Iterable._check(queryParameterLists[dartx.get](key))));
+ queryParameterLists[dartx._set](key, ListOfString().unmodifiable(core.Iterable._check(queryParameterLists[dartx._get](key))));
}
this[_queryParameterLists] = MapOfString$ListOfString().unmodifiable(queryParameterLists);
}
@@ -34879,7 +34878,7 @@
return core.Uri._normalizeRegName(host, start, end);
}
static _isRegNameChar(char) {
- return dart.notNull(char) < 127 && (dart.notNull(core.Uri._regNameTable[dartx.get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
+ return dart.notNull(char) < 127 && (dart.notNull(core.Uri._regNameTable[dartx._get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
}
static _normalizeRegName(host, start, end) {
let buffer = null;
@@ -35074,9 +35073,9 @@
let codeUnits = null;
if (dart.notNull(char) < 128) {
codeUnits = ListOfint().new(3);
- codeUnits[dartx.set](0, core.Uri._PERCENT);
- codeUnits[dartx.set](1, core.Uri._hexDigits[dartx.codeUnitAt](char[dartx['>>']](4)));
- codeUnits[dartx.set](2, core.Uri._hexDigits[dartx.codeUnitAt](dart.notNull(char) & 15));
+ codeUnits[dartx._set](0, core.Uri._PERCENT);
+ codeUnits[dartx._set](1, core.Uri._hexDigits[dartx.codeUnitAt](char[dartx['>>']](4)));
+ codeUnits[dartx._set](2, core.Uri._hexDigits[dartx.codeUnitAt](dart.notNull(char) & 15));
} else {
let flag = 192;
let encodedBytes = 2;
@@ -35092,9 +35091,9 @@
let index = 0;
while (--encodedBytes >= 0) {
let byte = (char[dartx['>>']](6 * encodedBytes) & 63 | flag) >>> 0;
- codeUnits[dartx.set](index, core.Uri._PERCENT);
- codeUnits[dartx.set](index + 1, core.Uri._hexDigits[dartx.codeUnitAt](byte[dartx['>>']](4)));
- codeUnits[dartx.set](index + 2, core.Uri._hexDigits[dartx.codeUnitAt](byte & 15));
+ codeUnits[dartx._set](index, core.Uri._PERCENT);
+ codeUnits[dartx._set](index + 1, core.Uri._hexDigits[dartx.codeUnitAt](byte[dartx['>>']](4)));
+ codeUnits[dartx._set](index + 2, core.Uri._hexDigits[dartx.codeUnitAt](byte & 15));
index = index + 3;
flag = 128;
}
@@ -35107,7 +35106,7 @@
let index = start;
while (dart.notNull(index) < dart.notNull(end)) {
let char = component[dartx.codeUnitAt](index);
- if (dart.notNull(char) < 127 && (dart.notNull(charTable[dartx.get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0) {
+ if (dart.notNull(char) < 127 && (dart.notNull(charTable[dartx._get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0) {
index = dart.notNull(index) + 1;
} else {
let replacement = null;
@@ -35155,10 +35154,10 @@
return dart.toString(buffer);
}
static _isSchemeCharacter(ch) {
- return dart.notNull(ch) < 128 && (dart.notNull(core.Uri._schemeTable[dartx.get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
+ return dart.notNull(ch) < 128 && (dart.notNull(core.Uri._schemeTable[dartx._get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
}
static _isGeneralDelimiter(ch) {
- return dart.notNull(ch) <= core.Uri._RIGHT_BRACKET && (dart.notNull(core.Uri._genDelimitersTable[dartx.get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
+ return dart.notNull(ch) <= core.Uri._RIGHT_BRACKET && (dart.notNull(core.Uri._genDelimitersTable[dartx._get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
}
get isAbsolute() {
return this.scheme != "" && this.fragment == "";
@@ -35235,7 +35234,7 @@
output[dartx.add](segment);
}
}
- if (dart.test(output[dartx.isEmpty]) || output[dartx.length] == 1 && dart.test(output[dartx.get](0)[dartx.isEmpty])) {
+ if (dart.test(output[dartx.isEmpty]) || output[dartx.length] == 1 && dart.test(output[dartx._get](0)[dartx.isEmpty])) {
return "./";
}
if (appendSlash || output[dartx.last] == '..') output[dartx.add]("");
@@ -35365,8 +35364,8 @@
[_toWindowsFilePath]() {
let hasDriveLetter = false;
let segments = this.pathSegments;
- if (dart.notNull(segments[dartx.length]) > 0 && segments[dartx.get](0)[dartx.length] == 2 && segments[dartx.get](0)[dartx.codeUnitAt](1) == core.Uri._COLON) {
- core.Uri._checkWindowsDriveLetter(segments[dartx.get](0)[dartx.codeUnitAt](0), false);
+ if (dart.notNull(segments[dartx.length]) > 0 && segments[dartx._get](0)[dartx.length] == 2 && segments[dartx._get](0)[dartx.codeUnitAt](1) == core.Uri._COLON) {
+ core.Uri._checkWindowsDriveLetter(segments[dartx._get](0)[dartx.codeUnitAt](0), false);
core.Uri._checkWindowsPathReservedCharacters(segments, false, 1);
hasDriveLetter = true;
} else {
@@ -35463,12 +35462,12 @@
let index = element[dartx.indexOf]("=");
if (index == -1) {
if (element != "") {
- map[dartx.set](core.Uri.decodeQueryComponent(element, {encoding: encoding}), "");
+ map[dartx._set](core.Uri.decodeQueryComponent(element, {encoding: encoding}), "");
}
} else if (index != 0) {
let key = element[dartx.substring](0, index);
let value = element[dartx.substring](dart.notNull(index) + 1);
- map[dartx.set](core.Uri.decodeQueryComponent(key, {encoding: encoding}), core.Uri.decodeQueryComponent(value, {encoding: encoding}));
+ map[dartx._set](core.Uri.decodeQueryComponent(key, {encoding: encoding}), core.Uri.decodeQueryComponent(value, {encoding: encoding}));
}
return map;
}, MapOfString$StringAndStringToMapOfString$String()));
@@ -35586,8 +35585,8 @@
} catch (e) {
try {
let last = core.Uri.parseIPv4Address(host[dartx.substring](partStart, end));
- parts[dartx.add]((dart.notNull(last[dartx.get](0)) << 8 | dart.notNull(last[dartx.get](1))) >>> 0);
- parts[dartx.add]((dart.notNull(last[dartx.get](2)) << 8 | dart.notNull(last[dartx.get](3))) >>> 0);
+ parts[dartx.add]((dart.notNull(last[dartx._get](0)) << 8 | dart.notNull(last[dartx._get](1))) >>> 0);
+ parts[dartx.add]((dart.notNull(last[dartx._get](2)) << 8 | dart.notNull(last[dartx._get](3))) >>> 0);
} catch (e) {
error('invalid end of IPv6 address.', partStart);
}
@@ -35604,17 +35603,17 @@
}
let bytes = typed_data.Uint8List.new(16);
for (let i = 0, index = 0; i < dart.notNull(parts[dartx.length]); i++) {
- let value = parts[dartx.get](i);
+ let value = parts[dartx._get](i);
if (value == -1) {
let wildCardLength = 9 - dart.notNull(parts[dartx.length]);
for (let j = 0; j < wildCardLength; j++) {
- bytes[dartx.set](index, 0);
- bytes[dartx.set](index + 1, 0);
+ bytes[dartx._set](index, 0);
+ bytes[dartx._set](index + 1, 0);
index = index + 2;
}
} else {
- bytes[dartx.set](index, value[dartx['>>']](8));
- bytes[dartx.set](index + 1, dart.notNull(value) & 255);
+ bytes[dartx._set](index, value[dartx['>>']](8));
+ bytes[dartx._set](index + 1, dart.notNull(value) & 255);
index = index + 2;
}
}
@@ -35627,16 +35626,16 @@
let result = new core.StringBuffer();
let bytes = encoding.encode(text);
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byte = bytes[dartx.get](i);
- if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx.get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
+ let byte = bytes[dartx._get](i);
+ if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx._get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
result.writeCharCode(byte);
} else if (dart.test(spaceToPlus) && byte == core.Uri._SPACE) {
result.write('+');
} else {
let hexDigits = '0123456789ABCDEF';
result.write('%');
- result.write(hexDigits[dartx.get](dart.notNull(byte) >> 4 & 15));
- result.write(hexDigits[dartx.get](dart.notNull(byte) & 15));
+ result.write(hexDigits[dartx._get](dart.notNull(byte) >> 4 & 15));
+ result.write(hexDigits[dartx._get](dart.notNull(byte) & 15));
}
}
return result.toString();
@@ -35705,7 +35704,7 @@
return core.Uri._LOWER_CASE_A <= lowerCase && lowerCase <= core.Uri._LOWER_CASE_Z;
}
static _isUnreservedChar(char) {
- return dart.notNull(char) < 127 && (dart.notNull(core.Uri._unreservedTable[dartx.get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
+ return dart.notNull(char) < 127 && (dart.notNull(core.Uri._unreservedTable[dartx._get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
}
};
dart.defineNamedConstructor(core.Uri, '_internal');
@@ -35923,7 +35922,7 @@
let indices = JSArrayOfint().of([core.UriData._noScheme]);
let charsetName = null;
let encodingName = null;
- if (parameters != null) charsetName = parameters[dartx.get]("charset");
+ if (parameters != null) charsetName = parameters[dartx._get]("charset");
if (encoding == null) {
if (charsetName != null) {
encoding = convert.Encoding.getByName(charsetName);
@@ -36039,7 +36038,7 @@
if (this[_uriCache] != null) return this[_uriCache];
let path = this[_text];
let query = null;
- let colonIndex = this[_separatorIndices][dartx.get](0);
+ let colonIndex = this[_separatorIndices][dartx._get](0);
let queryIndex = this[_text][dartx.indexOf]('?', dart.notNull(colonIndex) + 1);
let end = null;
if (dart.notNull(queryIndex) >= 0) {
@@ -36051,8 +36050,8 @@
return this[_uriCache];
}
get mimeType() {
- let start = dart.notNull(this[_separatorIndices][dartx.get](0)) + 1;
- let end = this[_separatorIndices][dartx.get](1);
+ let start = dart.notNull(this[_separatorIndices][dartx._get](0)) + 1;
+ let end = this[_separatorIndices][dartx._get](1);
if (start == end) return "text/plain";
return core.Uri._uriDecode(this[_text], start, end, convert.UTF8, false);
}
@@ -36063,10 +36062,10 @@
parameterEnd = parameterEnd - 1;
}
for (let i = parameterStart; i < parameterEnd; i = i + 2) {
- let keyStart = dart.notNull(this[_separatorIndices][dartx.get](i)) + 1;
- let keyEnd = this[_separatorIndices][dartx.get](i + 1);
+ let keyStart = dart.notNull(this[_separatorIndices][dartx._get](i)) + 1;
+ let keyEnd = this[_separatorIndices][dartx._get](i + 1);
if (keyEnd == keyStart + 7 && dart.test(this[_text][dartx.startsWith]("charset", keyStart))) {
- return core.Uri._uriDecode(this[_text], dart.notNull(keyEnd) + 1, this[_separatorIndices][dartx.get](i + 2), convert.UTF8, false);
+ return core.Uri._uriDecode(this[_text], dart.notNull(keyEnd) + 1, this[_separatorIndices][dartx._get](i + 2), convert.UTF8, false);
}
}
return "US-ASCII";
@@ -36101,14 +36100,14 @@
for (let i = start; i < dart.notNull(text[dartx.length]); i++) {
let codeUnit = text[dartx.codeUnitAt](i);
if (codeUnit != percent) {
- result[dartx.set](index++, codeUnit);
+ result[dartx._set](index++, codeUnit);
} else {
if (i + 2 < dart.notNull(text[dartx.length])) {
let digit1 = core.Uri._parseHexDigit(text[dartx.codeUnitAt](i + 1));
let digit2 = core.Uri._parseHexDigit(text[dartx.codeUnitAt](i + 2));
if (dart.notNull(digit1) >= 0 && dart.notNull(digit2) >= 0) {
let byte = dart.notNull(digit1) * 16 + dart.notNull(digit2);
- result[dartx.set](index++, byte);
+ result[dartx._set](index++, byte);
i = i + 2;
continue;
}
@@ -36139,12 +36138,12 @@
get parameters() {
let result = dart.map({}, core.String, core.String);
for (let i = 3; i < dart.notNull(this[_separatorIndices][dartx.length]); i = i + 2) {
- let start = dart.notNull(this[_separatorIndices][dartx.get](i - 2)) + 1;
- let equals = this[_separatorIndices][dartx.get](i - 1);
- let end = this[_separatorIndices][dartx.get](i);
+ let start = dart.notNull(this[_separatorIndices][dartx._get](i - 2)) + 1;
+ let equals = this[_separatorIndices][dartx._get](i - 1);
+ let end = this[_separatorIndices][dartx._get](i);
let key = core.Uri._uriDecode(this[_text], start, equals, convert.UTF8, false);
let value = core.Uri._uriDecode(this[_text], dart.notNull(equals) + 1, end, convert.UTF8, false);
- result[dartx.set](key, value);
+ result[dartx._set](key, value);
}
return result;
}
@@ -36201,9 +36200,9 @@
static _uriEncodeBytes(canonicalTable, bytes, buffer) {
let byteOr = 0;
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
byteOr = (dart.notNull(byteOr) | dart.notNull(byte)) >>> 0;
- if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx.get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
+ if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx._get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
buffer.writeCharCode(byte);
} else {
buffer.writeCharCode(core.Uri._PERCENT);
@@ -36213,7 +36212,7 @@
}
if ((dart.notNull(byteOr) & ~255) != 0) {
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) {
dart.throw(new core.ArgumentError.value(byte, "non-byte value"));
}
@@ -36221,7 +36220,7 @@
}
}
toString() {
- return this[_separatorIndices][dartx.get](0) == core.UriData._noScheme ? dart.str`data:${this[_text]}` : this[_text];
+ return this[_separatorIndices][dartx._get](0) == core.UriData._noScheme ? dart.str`data:${this[_text]}` : this[_text];
}
};
dart.defineNamedConstructor(core.UriData, '_');
@@ -36294,7 +36293,7 @@
static spawn(entryPoint, message, opts) {
let paused = opts && 'paused' in opts ? opts.paused : false;
try {
- return _isolate_helper.IsolateNatives.spawnFunction(entryPoint, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx.get](1)), {pauseCapability: isolate.Capability._check(msg[dartx.get](2)), terminateCapability: isolate.Capability._check(msg[dartx.get](3))}), ListToIsolate()));
+ return _isolate_helper.IsolateNatives.spawnFunction(entryPoint, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx._get](1)), {pauseCapability: isolate.Capability._check(msg[dartx._get](2)), terminateCapability: isolate.Capability._check(msg[dartx._get](3))}), ListToIsolate()));
} catch (e) {
let st = dart.stackTrace(e);
return FutureOfIsolate().error(e, st);
@@ -36308,14 +36307,14 @@
try {
if (core.List.is(args)) {
for (let i = 0; i < dart.notNull(args[dartx.length]); i++) {
- if (!(typeof args[dartx.get](i) == 'string')) {
+ if (!(typeof args[dartx._get](i) == 'string')) {
dart.throw(new core.ArgumentError(dart.str`Args must be a list of Strings ${args}`));
}
}
} else if (args != null) {
dart.throw(new core.ArgumentError(dart.str`Args must be a list of Strings ${args}`));
}
- return _isolate_helper.IsolateNatives.spawnUri(uri, args, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx.get](1)), {pauseCapability: isolate.Capability._check(msg[dartx.get](2)), terminateCapability: isolate.Capability._check(msg[dartx.get](3))}), ListToIsolate()));
+ return _isolate_helper.IsolateNatives.spawnUri(uri, args, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx._get](1)), {pauseCapability: isolate.Capability._check(msg[dartx._get](2)), terminateCapability: isolate.Capability._check(msg[dartx._get](3))}), ListToIsolate()));
} catch (e) {
let st = dart.stackTrace(e);
return FutureOfIsolate().error(e, st);
@@ -36330,34 +36329,34 @@
}
[_pause](resumeCapability) {
let message = core.List.new(3);
- message[dartx.set](0, "pause");
- message[dartx.set](1, this.pauseCapability);
- message[dartx.set](2, resumeCapability);
+ message[dartx._set](0, "pause");
+ message[dartx._set](1, this.pauseCapability);
+ message[dartx._set](2, resumeCapability);
this.controlPort.send(message);
}
resume(resumeCapability) {
let message = core.List.new(2);
- message[dartx.set](0, "resume");
- message[dartx.set](1, resumeCapability);
+ message[dartx._set](0, "resume");
+ message[dartx._set](1, resumeCapability);
this.controlPort.send(message);
}
addOnExitListener(responsePort) {
let message = core.List.new(2);
- message[dartx.set](0, "add-ondone");
- message[dartx.set](1, responsePort);
+ message[dartx._set](0, "add-ondone");
+ message[dartx._set](1, responsePort);
this.controlPort.send(message);
}
removeOnExitListener(responsePort) {
let message = core.List.new(2);
- message[dartx.set](0, "remove-ondone");
- message[dartx.set](1, responsePort);
+ message[dartx._set](0, "remove-ondone");
+ message[dartx._set](1, responsePort);
this.controlPort.send(message);
}
setErrorsFatal(errorsAreFatal) {
let message = core.List.new(3);
- message[dartx.set](0, "set-errors-fatal");
- message[dartx.set](1, this.terminateCapability);
- message[dartx.set](2, errorsAreFatal);
+ message[dartx._set](0, "set-errors-fatal");
+ message[dartx._set](1, this.terminateCapability);
+ message[dartx._set](2, errorsAreFatal);
this.controlPort.send(message);
}
kill(priority) {
@@ -36367,21 +36366,21 @@
ping(responsePort, pingType) {
if (pingType === void 0) pingType = isolate.Isolate.IMMEDIATE;
let message = core.List.new(3);
- message[dartx.set](0, "ping");
- message[dartx.set](1, responsePort);
- message[dartx.set](2, pingType);
+ message[dartx._set](0, "ping");
+ message[dartx._set](1, responsePort);
+ message[dartx._set](2, pingType);
this.controlPort.send(message);
}
addErrorListener(port) {
let message = core.List.new(2);
- message[dartx.set](0, "getErrors");
- message[dartx.set](1, port);
+ message[dartx._set](0, "getErrors");
+ message[dartx._set](1, port);
this.controlPort.send(message);
}
removeErrorListener(port) {
let message = core.List.new(2);
- message[dartx.set](0, "stopErrors");
- message[dartx.set](1, port);
+ message[dartx._set](0, "stopErrors");
+ message[dartx._set](1, port);
this.controlPort.send(message);
}
get errors() {
@@ -36572,18 +36571,18 @@
let _convertedObjects = collection.HashMap.identity();
function _convert(o) {
if (dart.test(_convertedObjects.containsKey(o))) {
- return _convertedObjects.get(o);
+ return _convertedObjects._get(o);
}
if (core.Map.is(o)) {
let convertedMap = {};
- _convertedObjects.set(o, convertedMap);
+ _convertedObjects._set(o, convertedMap);
for (let key of o[dartx.keys]) {
- convertedMap[key] = _convert(o[dartx.get](key));
+ convertedMap[key] = _convert(o[dartx._get](key));
}
return convertedMap;
} else if (core.Iterable.is(o)) {
let convertedList = [];
- _convertedObjects.set(o, convertedList);
+ _convertedObjects._set(o, convertedList);
convertedList[dartx.addAll](o[dartx.map](dart.dynamic)(_convert));
return convertedList;
} else {
@@ -36593,13 +36592,13 @@
dart.fn(_convert, dynamicTodynamic$());
return _convert(data);
}
- get(property) {
+ _get(property) {
if (!(typeof property == 'string') && !(typeof property == 'number')) {
dart.throw(new core.ArgumentError("property is not a String or num"));
}
return js._convertToDart(this[_jsObject][property]);
}
- set(property, value) {
+ _set(property, value) {
if (!(typeof property == 'string') && !(typeof property == 'number')) {
dart.throw(new core.ArgumentError("property is not a String or num"));
}
@@ -36658,8 +36657,8 @@
}),
fields: () => ({[_jsObject]: dart.dynamic}),
methods: () => ({
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
- set: dart.definiteFunctionType(dart.dynamic, [core.Object, dart.dynamic]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _set: dart.definiteFunctionType(dart.dynamic, [core.Object, dart.dynamic]),
hasProperty: dart.definiteFunctionType(core.bool, [dart.dynamic]),
deleteProperty: dart.definiteFunctionType(dart.void, [dart.dynamic]),
instanceof: dart.definiteFunctionType(core.bool, [js.JsFunction]),
@@ -36733,18 +36732,18 @@
dart.throw(new core.RangeError.range(end, start, length));
}
}
- get(index) {
+ _get(index) {
if (typeof index == 'number' && index == index[dartx.toInt]()) {
this[_checkIndex](dart.asInt(index));
}
- return E.as(super.get(index));
+ return E.as(super._get(index));
}
- set(index, value) {
+ _set(index, value) {
E._check(value);
if (typeof index == 'number' && index == index[dartx.toInt]()) {
this[_checkIndex](dart.asInt(index));
}
- super.set(index, value);
+ super._set(index, value);
return value;
}
get length() {
@@ -36755,7 +36754,7 @@
dart.throw(new core.StateError('Bad JsArray length'));
}
set length(length) {
- super.set('length', length);
+ super._set('length', length);
}
add(value) {
E._check(value);
@@ -36813,8 +36812,8 @@
methods: () => ({
[_checkIndex]: dart.definiteFunctionType(dart.dynamic, [core.int]),
[_checkInsertIndex]: dart.definiteFunctionType(dart.dynamic, [core.int]),
- get: dart.definiteFunctionType(E, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.Object, E]),
+ _get: dart.definiteFunctionType(E, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.Object, E]),
add: dart.definiteFunctionType(dart.void, [E]),
addAll: dart.definiteFunctionType(dart.void, [IterableOfE()]),
insert: dart.definiteFunctionType(dart.void, [core.int, E]),
@@ -36827,8 +36826,8 @@
names: ['_checkRange']
});
dart.defineExtensionMembers(JsArray, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'add',
'addAll',
'insert',
@@ -36935,7 +36934,7 @@
set _interopCaptureThisExpando(_) {}
});
js.allowInteropCaptureThis = function(f) {
- let ret = js._interopCaptureThisExpando.get(f);
+ let ret = js._interopCaptureThisExpando._get(f);
if (ret == null) {
ret = function() {
let args = [this];
@@ -36944,7 +36943,7 @@
}
return f(...args);
};
- js._interopCaptureThisExpando.set(f, ret);
+ js._interopCaptureThisExpando._set(f, ret);
}
return ret;
};
@@ -36960,18 +36959,18 @@
let _convertedObjects = collection.HashMap.identity();
function _convert(o) {
if (dart.test(_convertedObjects.containsKey(o))) {
- return _convertedObjects.get(o);
+ return _convertedObjects._get(o);
}
if (core.Map.is(o)) {
let convertedMap = {};
- _convertedObjects.set(o, convertedMap);
+ _convertedObjects._set(o, convertedMap);
for (let key of o[dartx.keys]) {
- convertedMap[key] = _convert(o[dartx.get](key));
+ convertedMap[key] = _convert(o[dartx._get](key));
}
return convertedMap;
} else if (core.Iterable.is(o)) {
let convertedList = [];
- _convertedObjects.set(o, convertedList);
+ _convertedObjects._set(o, convertedList);
convertedList[dartx.addAll](o[dartx.map](dart.dynamic)(_convert));
return convertedList;
} else {
@@ -37582,11 +37581,35 @@
'height'
]);
class Rectangle extends math._RectangleBase$(T) {
+ get left() {
+ return this[left$];
+ }
+ set left(value) {
+ super.left = value;
+ }
+ get top() {
+ return this[top$];
+ }
+ set top(value) {
+ super.top = value;
+ }
+ get width() {
+ return this[width$];
+ }
+ set width(value) {
+ super.width = value;
+ }
+ get height() {
+ return this[height$];
+ }
+ set height(value) {
+ super.height = value;
+ }
new(left, top, width, height) {
- this[dartx.left] = left;
- this[dartx.top] = top;
- this[dartx.width] = dart.notNull(width) < 0 ? -dart.notNull(width) * 0 : width;
- this[dartx.height] = dart.notNull(height) < 0 ? -dart.notNull(height) * 0 : height;
+ this[left$] = left;
+ this[top$] = top;
+ this[width$] = dart.notNull(width) < 0 ? -dart.notNull(width) * 0 : width;
+ this[height$] = dart.notNull(height) < 0 ? -dart.notNull(height) * 0 : height;
super.new();
}
static fromPoints(a, b) {
@@ -37597,6 +37620,10 @@
return new (RectangleOfT())(left, top, width, height);
}
}
+ const left$ = Symbol(Rectangle.name + "." + 'left'.toString());
+ const top$ = Symbol(Rectangle.name + "." + 'top'.toString());
+ const width$ = Symbol(Rectangle.name + "." + 'width'.toString());
+ const height$ = Symbol(Rectangle.name + "." + 'height'.toString());
dart.setSignature(Rectangle, {
constructors: () => ({
new: dart.definiteFunctionType(math.Rectangle$(T), [T, T, T, T]),
@@ -37620,9 +37647,21 @@
let RectangleOfT = () => (RectangleOfT = dart.constFn(math.Rectangle$(T)))();
let PointOfT = () => (PointOfT = dart.constFn(math.Point$(T)))();
class MutableRectangle extends math._RectangleBase$(T) {
+ get left() {
+ return this[left$];
+ }
+ set left(value) {
+ this[left$] = value;
+ }
+ get top() {
+ return this[top$];
+ }
+ set top(value) {
+ this[top$] = value;
+ }
new(left, top, width, height) {
- this.left = left;
- this.top = top;
+ this[left$] = left;
+ this[top$] = top;
this[_width] = dart.notNull(width) < 0 ? math._clampToZero(T)(width) : width;
this[_height] = dart.notNull(height) < 0 ? math._clampToZero(T)(height) : height;
super.new();
@@ -37651,6 +37690,8 @@
this[_height] = height;
}
}
+ const left$ = Symbol(MutableRectangle.name + "." + 'left'.toString());
+ const top$ = Symbol(MutableRectangle.name + "." + 'top'.toString());
MutableRectangle[dart.implements] = () => [RectangleOfT()];
dart.setSignature(MutableRectangle, {
constructors: () => ({
@@ -38229,7 +38270,7 @@
if (dart.test(html_common.isJavaScriptDate(object))) return true;
if (core.List.is(object)) {
for (let i = 0; i < dart.notNull(object[dartx.length]); i++) {
- if (dart.test(containsDate(object[dartx.get](i)))) return true;
+ if (dart.test(containsDate(object[dartx._get](i)))) return true;
}
}
return false;
@@ -38448,10 +38489,10 @@
let autoIncrement = opts && 'autoIncrement' in opts ? opts.autoIncrement : null;
let options = dart.map();
if (keyPath != null) {
- options[dartx.set]('keyPath', keyPath);
+ options[dartx._set]('keyPath', keyPath);
}
if (autoIncrement != null) {
- options[dartx.set]('autoIncrement', autoIncrement);
+ options[dartx._set]('autoIncrement', autoIncrement);
}
return this[_createObjectStore](name, options);
}
@@ -39043,10 +39084,10 @@
let multiEntry = opts && 'multiEntry' in opts ? opts.multiEntry : null;
let options = dart.map();
if (unique != null) {
- options[dartx.set]('unique', unique);
+ options[dartx._set]('unique', unique);
}
if (multiEntry != null) {
- options[dartx.set]('multiEntry', multiEntry);
+ options[dartx._set]('multiEntry', multiEntry);
}
return this[_createIndex](name, keyPath, options);
}
@@ -40225,7 +40266,7 @@
let attributes = this[dartx.attributes];
attributes[dartx.clear]();
for (let key of value[dartx.keys]) {
- attributes[dartx.set](key, value[dartx.get](key));
+ attributes[dartx._set](key, value[dartx._get](key));
}
}
get [dartx.children]() {
@@ -40265,7 +40306,7 @@
let data = this[dartx.dataset];
data[dartx.clear]();
for (let key of value[dartx.keys]) {
- data[dartx.set](key, value[dartx.get](key));
+ data[dartx._set](key, value[dartx._get](key));
}
}
[dartx.getNamespacedAttributes](namespace) {
@@ -40414,7 +40455,7 @@
}
case 'afterbegin':
{
- let first = dart.notNull(this[dartx.nodes][dartx.length]) > 0 ? this[dartx.nodes][dartx.get](0) : null;
+ let first = dart.notNull(this[dartx.nodes][dartx.length]) > 0 ? this[dartx.nodes][dartx._get](0) : null;
this[dartx.insertBefore](node, first);
break;
}
@@ -53164,7 +53205,7 @@
'clear',
'item',
'remove',
- 'get',
+ '_get',
'length'
]);
html$.DataTransferItemList = class DataTransferItemList extends _interceptors.Interceptor {
@@ -53192,7 +53233,7 @@
[dartx.remove](index) {
return this.remove(index);
}
- [dartx.get](index) {
+ [dartx._get](index) {
return this[index];
}
};
@@ -53206,7 +53247,7 @@
[dartx.clear]: dart.definiteFunctionType(dart.void, []),
[dartx.item]: dart.definiteFunctionType(html$.DataTransferItem, [core.int]),
[dartx.remove]: dart.definiteFunctionType(dart.void, [core.int]),
- [dartx.get]: dart.definiteFunctionType(html$.DataTransferItem, [core.int])
+ [dartx._get]: dart.definiteFunctionType(html$.DataTransferItem, [core.int])
})
});
dart.registerExtension(dart.global.DataTransferItemList, html$.DataTransferItemList);
@@ -56037,8 +56078,8 @@
html$.ImmutableListMixin = ImmutableListMixin();
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -56053,11 +56094,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.item](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -56086,7 +56127,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__getter__](index) {
return this.__getter__(index);
@@ -56106,8 +56147,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.String, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
[dartx.elementAt]: dart.definiteFunctionType(core.String, [core.int]),
[__getter__]: dart.definiteFunctionType(core.String, [core.int]),
[dartx.item]: dart.definiteFunctionType(core.String, [core.int])
@@ -56148,11 +56189,11 @@
get length() {
return this[_childElements][dartx.length];
}
- get(index) {
- return html$.Element._check(this[_childElements][dartx.get](index));
+ _get(index) {
+ return html$.Element._check(this[_childElements][dartx._get](index));
}
- set(index, value) {
- this[_element$][_replaceChild](value, this[_childElements][dartx.get](index));
+ _set(index, value) {
+ this[_element$][_replaceChild](value, this[_childElements][dartx._get](index));
return value;
}
set length(newLength) {
@@ -56225,7 +56266,7 @@
if (index == this.length) {
this[_element$][dartx.append](element);
} else {
- this[_element$][dartx.insertBefore](element, this.get(index));
+ this[_element$][dartx.insertBefore](element, this._get(index));
}
}
setAll(index, iterable) {
@@ -56235,7 +56276,7 @@
this[_element$][_clearChildren]();
}
removeAt(index) {
- let result = this.get(index);
+ let result = this._get(index);
if (result != null) {
this[_element$][_removeChild](result);
}
@@ -56285,8 +56326,8 @@
}),
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- get: dart.definiteFunctionType(html$.Element, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
+ _get: dart.definiteFunctionType(html$.Element, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
add: dart.definiteFunctionType(html$.Element, [html$.Element]),
addAll: dart.definiteFunctionType(dart.void, [IterableOfElement()]),
sort: dart.definiteFunctionType(dart.void, [], [ElementAndElementToint()]),
@@ -56304,8 +56345,8 @@
});
dart.defineExtensionMembers(html$._ChildrenElementList, [
'contains',
- 'get',
- 'set',
+ '_get',
+ '_set',
'add',
'addAll',
'sort',
@@ -56347,10 +56388,10 @@
get length() {
return this[_nodeList][dartx.length];
}
- get(index) {
- return html$._downcast(html$.Node, E)(this[_nodeList][dartx.get](index));
+ _get(index) {
+ return html$._downcast(html$.Node, E)(this[_nodeList][dartx._get](index));
}
- set(index, value) {
+ _set(index, value) {
E._check(value);
dart.throw(new core.UnsupportedError('Cannot modify list'));
return value;
@@ -56699,14 +56740,14 @@
classes: dart.definiteFunctionType(dart.void, [IterableOfString()])
}),
methods: () => ({
- get: dart.definiteFunctionType(E, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _get: dart.definiteFunctionType(E, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
sort: dart.definiteFunctionType(dart.void, [], [ComparatorOfE()])
})
});
dart.defineExtensionMembers(_FrozenElementList, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sort',
'shuffle',
'length',
@@ -57012,23 +57053,23 @@
new(ptr) {
this[_ptr] = ptr;
}
- get(type) {
+ _get(type) {
return new (_EventStreamOfEvent())(this[_ptr], type, false);
}
};
dart.setSignature(html$.Events, {
constructors: () => ({new: dart.definiteFunctionType(html$.Events, [html$.EventTarget])}),
fields: () => ({[_ptr]: html$.EventTarget}),
- methods: () => ({get: dart.definiteFunctionType(async.Stream, [core.String])})
+ methods: () => ({_get: dart.definiteFunctionType(async.Stream, [core.String])})
});
html$.ElementEvents = class ElementEvents extends html$.Events {
new(ptr) {
super.new(ptr);
}
- get(type) {
+ _get(type) {
if (dart.test(html$.ElementEvents.webkitEvents[dartx.keys][dartx.contains](type[dartx.toLowerCase]()))) {
if (dart.test(html_common.Device.isWebKit)) {
- return new (_ElementEventStreamImplOfEvent())(this[_ptr], html$.ElementEvents.webkitEvents[dartx.get](type[dartx.toLowerCase]()), false);
+ return new (_ElementEventStreamImplOfEvent())(this[_ptr], html$.ElementEvents.webkitEvents[dartx._get](type[dartx.toLowerCase]()), false);
}
}
return new (_ElementEventStreamImplOfEvent())(this[_ptr], type, false);
@@ -57411,8 +57452,8 @@
dart.registerExtension(dart.global.FileError, html$.FileError);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -57427,11 +57468,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -57460,7 +57501,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -57477,8 +57518,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.File, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.File]),
+ [dartx._get]: dart.definiteFunctionType(html$.File, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.File]),
[dartx.elementAt]: dart.definiteFunctionType(html$.File, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.File, [core.int])
})
@@ -58411,13 +58452,13 @@
let maximumAge = opts && 'maximumAge' in opts ? opts.maximumAge : null;
let options = dart.map();
if (enableHighAccuracy != null) {
- options[dartx.set]('enableHighAccuracy', enableHighAccuracy);
+ options[dartx._set]('enableHighAccuracy', enableHighAccuracy);
}
if (timeout != null) {
- options[dartx.set]('timeout', timeout.inMilliseconds);
+ options[dartx._set]('timeout', timeout.inMilliseconds);
}
if (maximumAge != null) {
- options[dartx.set]('maximumAge', maximumAge.inMilliseconds);
+ options[dartx._set]('maximumAge', maximumAge.inMilliseconds);
}
let completer = CompleterOfGeoposition().new();
try {
@@ -58439,13 +58480,13 @@
let maximumAge = opts && 'maximumAge' in opts ? opts.maximumAge : null;
let options = dart.map();
if (enableHighAccuracy != null) {
- options[dartx.set]('enableHighAccuracy', enableHighAccuracy);
+ options[dartx._set]('enableHighAccuracy', enableHighAccuracy);
}
if (timeout != null) {
- options[dartx.set]('timeout', timeout.inMilliseconds);
+ options[dartx._set]('timeout', timeout.inMilliseconds);
}
if (maximumAge != null) {
- options[dartx.set]('maximumAge', maximumAge.inMilliseconds);
+ options[dartx._set]('maximumAge', maximumAge.inMilliseconds);
}
let watchId = null;
let controller = null;
@@ -59485,8 +59526,8 @@
dart.registerExtension(dart.global.HMDVRDevice, html$.HmdvrDevice);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -59502,11 +59543,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -59535,7 +59576,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -59555,8 +59596,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Node, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
+ [dartx._get]: dart.definiteFunctionType(html$.Node, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Node, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.Node, [core.int]),
[dartx.namedItem]: dart.definiteFunctionType(core.Object, [core.String])
@@ -59990,9 +60031,9 @@
let key = header[dartx.substring](0, splitIdx)[dartx.toLowerCase]();
let value = header[dartx.substring](dart.notNull(splitIdx) + 2);
if (dart.test(headers[dartx.containsKey](key))) {
- headers[dartx.set](key, dart.str`${headers[dartx.get](key)}, ${value}`);
+ headers[dartx._set](key, dart.str`${headers[dartx._get](key)}, ${value}`);
} else {
- headers[dartx.set](key, value);
+ headers[dartx._set](key, value);
}
}
return headers;
@@ -61048,14 +61089,56 @@
]);
html$.InputElementBase = class InputElementBase extends core.Object {
new() {
- this[dartx.autofocus] = null;
- this[dartx.disabled] = null;
- this[dartx.incremental] = null;
- this[dartx.indeterminate] = null;
- this[dartx.name] = null;
- this[dartx.value] = null;
+ this[autofocus] = null;
+ this[disabled] = null;
+ this[incremental] = null;
+ this[indeterminate] = null;
+ this[name] = null;
+ this[value$] = null;
+ }
+ get autofocus() {
+ return this[autofocus];
+ }
+ set autofocus(value) {
+ this[autofocus] = value;
+ }
+ get disabled() {
+ return this[disabled];
+ }
+ set disabled(value) {
+ this[disabled] = value;
+ }
+ get incremental() {
+ return this[incremental];
+ }
+ set incremental(value) {
+ this[incremental] = value;
+ }
+ get indeterminate() {
+ return this[indeterminate];
+ }
+ set indeterminate(value) {
+ this[indeterminate] = value;
+ }
+ get name() {
+ return this[name];
+ }
+ set name(value) {
+ this[name] = value;
+ }
+ get value() {
+ return this[value$];
+ }
+ set value(value) {
+ this[value$] = value;
}
};
+ const autofocus = Symbol(html$.InputElementBase.name + "." + 'autofocus'.toString());
+ const disabled = Symbol(html$.InputElementBase.name + "." + 'disabled'.toString());
+ const incremental = Symbol(html$.InputElementBase.name + "." + 'incremental'.toString());
+ const indeterminate = Symbol(html$.InputElementBase.name + "." + 'indeterminate'.toString());
+ const name = Symbol(html$.InputElementBase.name + "." + 'name'.toString());
+ const value$ = Symbol(html$.InputElementBase.name + "." + 'value'.toString());
html$.InputElementBase[dart.implements] = () => [html$.Element];
dart.setSignature(html$.InputElementBase, {
fields: () => ({
@@ -61104,18 +61187,88 @@
]);
html$.TextInputElementBase = class TextInputElementBase extends core.Object {
new() {
- this[dartx.autocomplete] = null;
- this[dartx.maxLength] = null;
- this[dartx.pattern] = null;
- this[dartx.placeholder] = null;
- this[dartx.readOnly] = null;
- this[dartx.required] = null;
- this[dartx.size] = null;
- this[dartx.selectionDirection] = null;
- this[dartx.selectionEnd] = null;
- this[dartx.selectionStart] = null;
+ this[autocomplete] = null;
+ this[maxLength] = null;
+ this[pattern] = null;
+ this[placeholder] = null;
+ this[readOnly] = null;
+ this[required] = null;
+ this[size] = null;
+ this[selectionDirection] = null;
+ this[selectionEnd] = null;
+ this[selectionStart] = null;
+ }
+ get autocomplete() {
+ return this[autocomplete];
+ }
+ set autocomplete(value) {
+ this[autocomplete] = value;
+ }
+ get maxLength() {
+ return this[maxLength];
+ }
+ set maxLength(value) {
+ this[maxLength] = value;
+ }
+ get pattern() {
+ return this[pattern];
+ }
+ set pattern(value) {
+ this[pattern] = value;
+ }
+ get placeholder() {
+ return this[placeholder];
+ }
+ set placeholder(value) {
+ this[placeholder] = value;
+ }
+ get readOnly() {
+ return this[readOnly];
+ }
+ set readOnly(value) {
+ this[readOnly] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
+ get size() {
+ return this[size];
+ }
+ set size(value) {
+ this[size] = value;
+ }
+ get selectionDirection() {
+ return this[selectionDirection];
+ }
+ set selectionDirection(value) {
+ this[selectionDirection] = value;
+ }
+ get selectionEnd() {
+ return this[selectionEnd];
+ }
+ set selectionEnd(value) {
+ this[selectionEnd] = value;
+ }
+ get selectionStart() {
+ return this[selectionStart];
+ }
+ set selectionStart(value) {
+ this[selectionStart] = value;
}
};
+ const autocomplete = Symbol(html$.TextInputElementBase.name + "." + 'autocomplete'.toString());
+ const maxLength = Symbol(html$.TextInputElementBase.name + "." + 'maxLength'.toString());
+ const pattern = Symbol(html$.TextInputElementBase.name + "." + 'pattern'.toString());
+ const placeholder = Symbol(html$.TextInputElementBase.name + "." + 'placeholder'.toString());
+ const readOnly = Symbol(html$.TextInputElementBase.name + "." + 'readOnly'.toString());
+ const required = Symbol(html$.TextInputElementBase.name + "." + 'required'.toString());
+ const size = Symbol(html$.TextInputElementBase.name + "." + 'size'.toString());
+ const selectionDirection = Symbol(html$.TextInputElementBase.name + "." + 'selectionDirection'.toString());
+ const selectionEnd = Symbol(html$.TextInputElementBase.name + "." + 'selectionEnd'.toString());
+ const selectionStart = Symbol(html$.TextInputElementBase.name + "." + 'selectionStart'.toString());
html$.TextInputElementBase[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.TextInputElementBase, {
fields: () => ({
@@ -61160,10 +61313,17 @@
static new() {
return html$.InputElement.new({type: 'search'});
}
+ get dirName() {
+ return this[dirName];
+ }
+ set dirName(value) {
+ this[dirName] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'search'})[dartx.type] == 'search';
}
};
+ const dirName = Symbol(html$.SearchInputElement.name + "." + 'dirName'.toString());
html$.SearchInputElement[dart.implements] = () => [html$.TextInputElementBase];
dart.setSignature(html$.SearchInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.SearchInputElement, [])}),
@@ -61178,7 +61338,14 @@
static new() {
return html$.InputElement.new({type: 'text'});
}
+ get dirName() {
+ return this[dirName$];
+ }
+ set dirName(value) {
+ this[dirName$] = value;
+ }
};
+ const dirName$ = Symbol(html$.TextInputElement.name + "." + 'dirName'.toString());
html$.TextInputElement[dart.implements] = () => [html$.TextInputElementBase];
dart.setSignature(html$.TextInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.TextInputElement, [])}),
@@ -61226,10 +61393,73 @@
static new() {
return html$.InputElement.new({type: 'email'});
}
+ get autocomplete() {
+ return this[autocomplete$];
+ }
+ set autocomplete(value) {
+ this[autocomplete$] = value;
+ }
+ get autofocus() {
+ return this[autofocus$];
+ }
+ set autofocus(value) {
+ this[autofocus$] = value;
+ }
+ get maxLength() {
+ return this[maxLength$];
+ }
+ set maxLength(value) {
+ this[maxLength$] = value;
+ }
+ get multiple() {
+ return this[multiple];
+ }
+ set multiple(value) {
+ this[multiple] = value;
+ }
+ get pattern() {
+ return this[pattern$];
+ }
+ set pattern(value) {
+ this[pattern$] = value;
+ }
+ get placeholder() {
+ return this[placeholder$];
+ }
+ set placeholder(value) {
+ this[placeholder$] = value;
+ }
+ get readOnly() {
+ return this[readOnly$];
+ }
+ set readOnly(value) {
+ this[readOnly$] = value;
+ }
+ get required() {
+ return this[required$];
+ }
+ set required(value) {
+ this[required$] = value;
+ }
+ get size() {
+ return this[size$];
+ }
+ set size(value) {
+ this[size$] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'email'})[dartx.type] == 'email';
}
};
+ const autocomplete$ = Symbol(html$.EmailInputElement.name + "." + 'autocomplete'.toString());
+ const autofocus$ = Symbol(html$.EmailInputElement.name + "." + 'autofocus'.toString());
+ const maxLength$ = Symbol(html$.EmailInputElement.name + "." + 'maxLength'.toString());
+ const multiple = Symbol(html$.EmailInputElement.name + "." + 'multiple'.toString());
+ const pattern$ = Symbol(html$.EmailInputElement.name + "." + 'pattern'.toString());
+ const placeholder$ = Symbol(html$.EmailInputElement.name + "." + 'placeholder'.toString());
+ const readOnly$ = Symbol(html$.EmailInputElement.name + "." + 'readOnly'.toString());
+ const required$ = Symbol(html$.EmailInputElement.name + "." + 'required'.toString());
+ const size$ = Symbol(html$.EmailInputElement.name + "." + 'size'.toString());
html$.EmailInputElement[dart.implements] = () => [html$.TextInputElementBase];
dart.setSignature(html$.EmailInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.EmailInputElement, [])}),
@@ -61283,12 +61513,40 @@
]);
html$.RangeInputElementBase = class RangeInputElementBase extends core.Object {
new() {
- this[dartx.max] = null;
- this[dartx.min] = null;
- this[dartx.step] = null;
- this[dartx.valueAsNumber] = null;
+ this[max] = null;
+ this[min] = null;
+ this[step] = null;
+ this[valueAsNumber] = null;
+ }
+ get max() {
+ return this[max];
+ }
+ set max(value) {
+ this[max] = value;
+ }
+ get min() {
+ return this[min];
+ }
+ set min(value) {
+ this[min] = value;
+ }
+ get step() {
+ return this[step];
+ }
+ set step(value) {
+ this[step] = value;
+ }
+ get valueAsNumber() {
+ return this[valueAsNumber];
+ }
+ set valueAsNumber(value) {
+ this[valueAsNumber] = value;
}
};
+ const max = Symbol(html$.RangeInputElementBase.name + "." + 'max'.toString());
+ const min = Symbol(html$.RangeInputElementBase.name + "." + 'min'.toString());
+ const step = Symbol(html$.RangeInputElementBase.name + "." + 'step'.toString());
+ const valueAsNumber = Symbol(html$.RangeInputElementBase.name + "." + 'valueAsNumber'.toString());
html$.RangeInputElementBase[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.RangeInputElementBase, {
fields: () => ({
@@ -61317,10 +61575,31 @@
static new() {
return html$.InputElement.new({type: 'date'});
}
+ get valueAsDate() {
+ return this[valueAsDate];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate] = value;
+ }
+ get readOnly() {
+ return this[readOnly$0];
+ }
+ set readOnly(value) {
+ this[readOnly$0] = value;
+ }
+ get required() {
+ return this[required$0];
+ }
+ set required(value) {
+ this[required$0] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'date'})[dartx.type] == 'date';
}
};
+ const valueAsDate = Symbol(html$.DateInputElement.name + "." + 'valueAsDate'.toString());
+ const readOnly$0 = Symbol(html$.DateInputElement.name + "." + 'readOnly'.toString());
+ const required$0 = Symbol(html$.DateInputElement.name + "." + 'required'.toString());
html$.DateInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.DateInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.DateInputElement, [])}),
@@ -61348,10 +61627,31 @@
static new() {
return html$.InputElement.new({type: 'month'});
}
+ get valueAsDate() {
+ return this[valueAsDate$];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate$] = value;
+ }
+ get readOnly() {
+ return this[readOnly$1];
+ }
+ set readOnly(value) {
+ this[readOnly$1] = value;
+ }
+ get required() {
+ return this[required$1];
+ }
+ set required(value) {
+ this[required$1] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'month'})[dartx.type] == 'month';
}
};
+ const valueAsDate$ = Symbol(html$.MonthInputElement.name + "." + 'valueAsDate'.toString());
+ const readOnly$1 = Symbol(html$.MonthInputElement.name + "." + 'readOnly'.toString());
+ const required$1 = Symbol(html$.MonthInputElement.name + "." + 'required'.toString());
html$.MonthInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.MonthInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.MonthInputElement, [])}),
@@ -61379,10 +61679,31 @@
static new() {
return html$.InputElement.new({type: 'week'});
}
+ get valueAsDate() {
+ return this[valueAsDate$0];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate$0] = value;
+ }
+ get readOnly() {
+ return this[readOnly$2];
+ }
+ set readOnly(value) {
+ this[readOnly$2] = value;
+ }
+ get required() {
+ return this[required$2];
+ }
+ set required(value) {
+ this[required$2] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'week'})[dartx.type] == 'week';
}
};
+ const valueAsDate$0 = Symbol(html$.WeekInputElement.name + "." + 'valueAsDate'.toString());
+ const readOnly$2 = Symbol(html$.WeekInputElement.name + "." + 'readOnly'.toString());
+ const required$2 = Symbol(html$.WeekInputElement.name + "." + 'required'.toString());
html$.WeekInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.WeekInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.WeekInputElement, [])}),
@@ -61410,10 +61731,31 @@
static new() {
return html$.InputElement.new({type: 'time'});
}
+ get valueAsDate() {
+ return this[valueAsDate$1];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate$1] = value;
+ }
+ get readOnly() {
+ return this[readOnly$3];
+ }
+ set readOnly(value) {
+ this[readOnly$3] = value;
+ }
+ get required() {
+ return this[required$3];
+ }
+ set required(value) {
+ this[required$3] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'time'})[dartx.type] == 'time';
}
};
+ const valueAsDate$1 = Symbol(html$.TimeInputElement.name + "." + 'valueAsDate'.toString());
+ const readOnly$3 = Symbol(html$.TimeInputElement.name + "." + 'readOnly'.toString());
+ const required$3 = Symbol(html$.TimeInputElement.name + "." + 'required'.toString());
html$.TimeInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.TimeInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.TimeInputElement, [])}),
@@ -61440,10 +61782,24 @@
static new() {
return html$.InputElement.new({type: 'datetime-local'});
}
+ get readOnly() {
+ return this[readOnly$4];
+ }
+ set readOnly(value) {
+ this[readOnly$4] = value;
+ }
+ get required() {
+ return this[required$4];
+ }
+ set required(value) {
+ this[required$4] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'datetime-local'})[dartx.type] == 'datetime-local';
}
};
+ const readOnly$4 = Symbol(html$.LocalDateTimeInputElement.name + "." + 'readOnly'.toString());
+ const required$4 = Symbol(html$.LocalDateTimeInputElement.name + "." + 'required'.toString());
html$.LocalDateTimeInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.LocalDateTimeInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.LocalDateTimeInputElement, [])}),
@@ -61463,10 +61819,31 @@
static new() {
return html$.InputElement.new({type: 'number'});
}
+ get placeholder() {
+ return this[placeholder$0];
+ }
+ set placeholder(value) {
+ this[placeholder$0] = value;
+ }
+ get readOnly() {
+ return this[readOnly$5];
+ }
+ set readOnly(value) {
+ this[readOnly$5] = value;
+ }
+ get required() {
+ return this[required$5];
+ }
+ set required(value) {
+ this[required$5] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'number'})[dartx.type] == 'number';
}
};
+ const placeholder$0 = Symbol(html$.NumberInputElement.name + "." + 'placeholder'.toString());
+ const readOnly$5 = Symbol(html$.NumberInputElement.name + "." + 'readOnly'.toString());
+ const required$5 = Symbol(html$.NumberInputElement.name + "." + 'required'.toString());
html$.NumberInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.NumberInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.NumberInputElement, [])}),
@@ -61506,7 +61883,21 @@
static new() {
return html$.InputElement.new({type: 'checkbox'});
}
+ get checked() {
+ return this[checked];
+ }
+ set checked(value) {
+ this[checked] = value;
+ }
+ get required() {
+ return this[required$6];
+ }
+ set required(value) {
+ this[required$6] = value;
+ }
};
+ const checked = Symbol(html$.CheckboxInputElement.name + "." + 'checked'.toString());
+ const required$6 = Symbol(html$.CheckboxInputElement.name + "." + 'required'.toString());
html$.CheckboxInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.CheckboxInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.CheckboxInputElement, [])}),
@@ -61524,7 +61915,21 @@
static new() {
return html$.InputElement.new({type: 'radio'});
}
+ get checked() {
+ return this[checked$];
+ }
+ set checked(value) {
+ this[checked$] = value;
+ }
+ get required() {
+ return this[required$7];
+ }
+ set required(value) {
+ this[required$7] = value;
+ }
};
+ const checked$ = Symbol(html$.RadioButtonInputElement.name + "." + 'checked'.toString());
+ const required$7 = Symbol(html$.RadioButtonInputElement.name + "." + 'required'.toString());
html$.RadioButtonInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.RadioButtonInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.RadioButtonInputElement, [])}),
@@ -61544,7 +61949,35 @@
static new() {
return html$.InputElement.new({type: 'file'});
}
+ get accept() {
+ return this[accept];
+ }
+ set accept(value) {
+ this[accept] = value;
+ }
+ get multiple() {
+ return this[multiple$];
+ }
+ set multiple(value) {
+ this[multiple$] = value;
+ }
+ get required() {
+ return this[required$8];
+ }
+ set required(value) {
+ this[required$8] = value;
+ }
+ get files() {
+ return this[files];
+ }
+ set files(value) {
+ this[files] = value;
+ }
};
+ const accept = Symbol(html$.FileUploadInputElement.name + "." + 'accept'.toString());
+ const multiple$ = Symbol(html$.FileUploadInputElement.name + "." + 'multiple'.toString());
+ const required$8 = Symbol(html$.FileUploadInputElement.name + "." + 'required'.toString());
+ const files = Symbol(html$.FileUploadInputElement.name + "." + 'files'.toString());
html$.FileUploadInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.FileUploadInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.FileUploadInputElement, [])}),
@@ -61576,7 +62009,42 @@
static new() {
return html$.InputElement.new({type: 'submit'});
}
+ get formAction() {
+ return this[formAction];
+ }
+ set formAction(value) {
+ this[formAction] = value;
+ }
+ get formEnctype() {
+ return this[formEnctype];
+ }
+ set formEnctype(value) {
+ this[formEnctype] = value;
+ }
+ get formMethod() {
+ return this[formMethod];
+ }
+ set formMethod(value) {
+ this[formMethod] = value;
+ }
+ get formNoValidate() {
+ return this[formNoValidate];
+ }
+ set formNoValidate(value) {
+ this[formNoValidate] = value;
+ }
+ get formTarget() {
+ return this[formTarget];
+ }
+ set formTarget(value) {
+ this[formTarget] = value;
+ }
};
+ const formAction = Symbol(html$.SubmitButtonInputElement.name + "." + 'formAction'.toString());
+ const formEnctype = Symbol(html$.SubmitButtonInputElement.name + "." + 'formEnctype'.toString());
+ const formMethod = Symbol(html$.SubmitButtonInputElement.name + "." + 'formMethod'.toString());
+ const formNoValidate = Symbol(html$.SubmitButtonInputElement.name + "." + 'formNoValidate'.toString());
+ const formTarget = Symbol(html$.SubmitButtonInputElement.name + "." + 'formTarget'.toString());
html$.SubmitButtonInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.SubmitButtonInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.SubmitButtonInputElement, [])}),
@@ -61615,7 +62083,70 @@
static new() {
return html$.InputElement.new({type: 'image'});
}
+ get alt() {
+ return this[alt];
+ }
+ set alt(value) {
+ this[alt] = value;
+ }
+ get formAction() {
+ return this[formAction$];
+ }
+ set formAction(value) {
+ this[formAction$] = value;
+ }
+ get formEnctype() {
+ return this[formEnctype$];
+ }
+ set formEnctype(value) {
+ this[formEnctype$] = value;
+ }
+ get formMethod() {
+ return this[formMethod$];
+ }
+ set formMethod(value) {
+ this[formMethod$] = value;
+ }
+ get formNoValidate() {
+ return this[formNoValidate$];
+ }
+ set formNoValidate(value) {
+ this[formNoValidate$] = value;
+ }
+ get formTarget() {
+ return this[formTarget$];
+ }
+ set formTarget(value) {
+ this[formTarget$] = value;
+ }
+ get height() {
+ return this[height];
+ }
+ set height(value) {
+ this[height] = value;
+ }
+ get src() {
+ return this[src];
+ }
+ set src(value) {
+ this[src] = value;
+ }
+ get width() {
+ return this[width];
+ }
+ set width(value) {
+ this[width] = value;
+ }
};
+ const alt = Symbol(html$.ImageButtonInputElement.name + "." + 'alt'.toString());
+ const formAction$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formAction'.toString());
+ const formEnctype$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formEnctype'.toString());
+ const formMethod$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formMethod'.toString());
+ const formNoValidate$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formNoValidate'.toString());
+ const formTarget$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formTarget'.toString());
+ const height = Symbol(html$.ImageButtonInputElement.name + "." + 'height'.toString());
+ const src = Symbol(html$.ImageButtonInputElement.name + "." + 'src'.toString());
+ const width = Symbol(html$.ImageButtonInputElement.name + "." + 'width'.toString());
html$.ImageButtonInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.ImageButtonInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.ImageButtonInputElement, [])}),
@@ -64189,8 +64720,8 @@
dart.registerExtension(dart.global.MimeType, html$.MimeType);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -64206,11 +64737,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -64239,7 +64770,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -64259,8 +64790,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.MimeType, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.MimeType]),
+ [dartx._get]: dart.definiteFunctionType(html$.MimeType, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.MimeType]),
[dartx.elementAt]: dart.definiteFunctionType(html$.MimeType, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.MimeType, [core.int]),
[dartx.namedItem]: dart.definiteFunctionType(html$.MimeType, [core.String])
@@ -64939,7 +65470,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get hardwareConcurrency() {
+ return this[hardwareConcurrency];
+ }
+ set hardwareConcurrency(value) {
+ super.hardwareConcurrency = value;
+ }
};
+ const hardwareConcurrency = Symbol(html$.NavigatorCpu.name + "." + 'hardwareConcurrency'.toString());
dart.setSignature(html$.NavigatorCpu, {
constructors: () => ({_: dart.definiteFunctionType(html$.NavigatorCpu, [])}),
fields: () => ({hardwareConcurrency: core.int})
@@ -64958,7 +65496,56 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get appCodeName() {
+ return this[appCodeName];
+ }
+ set appCodeName(value) {
+ super.appCodeName = value;
+ }
+ get appName() {
+ return this[appName];
+ }
+ set appName(value) {
+ super.appName = value;
+ }
+ get appVersion() {
+ return this[appVersion];
+ }
+ set appVersion(value) {
+ super.appVersion = value;
+ }
+ get dartEnabled() {
+ return this[dartEnabled];
+ }
+ set dartEnabled(value) {
+ super.dartEnabled = value;
+ }
+ get platform() {
+ return this[platform];
+ }
+ set platform(value) {
+ super.platform = value;
+ }
+ get product() {
+ return this[product];
+ }
+ set product(value) {
+ super.product = value;
+ }
+ get userAgent() {
+ return this[userAgent];
+ }
+ set userAgent(value) {
+ super.userAgent = value;
+ }
};
+ const appCodeName = Symbol(html$.NavigatorID.name + "." + 'appCodeName'.toString());
+ const appName = Symbol(html$.NavigatorID.name + "." + 'appName'.toString());
+ const appVersion = Symbol(html$.NavigatorID.name + "." + 'appVersion'.toString());
+ const dartEnabled = Symbol(html$.NavigatorID.name + "." + 'dartEnabled'.toString());
+ const platform = Symbol(html$.NavigatorID.name + "." + 'platform'.toString());
+ const product = Symbol(html$.NavigatorID.name + "." + 'product'.toString());
+ const userAgent = Symbol(html$.NavigatorID.name + "." + 'userAgent'.toString());
dart.setSignature(html$.NavigatorID, {
constructors: () => ({_: dart.definiteFunctionType(html$.NavigatorID, [])}),
fields: () => ({
@@ -64988,7 +65575,21 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get language() {
+ return this[language];
+ }
+ set language(value) {
+ super.language = value;
+ }
+ get languages() {
+ return this[languages];
+ }
+ set languages(value) {
+ super.languages = value;
+ }
};
+ const language = Symbol(html$.NavigatorLanguage.name + "." + 'language'.toString());
+ const languages = Symbol(html$.NavigatorLanguage.name + "." + 'languages'.toString());
dart.setSignature(html$.NavigatorLanguage, {
constructors: () => ({_: dart.definiteFunctionType(html$.NavigatorLanguage, [])}),
fields: () => ({
@@ -65004,7 +65605,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get onLine() {
+ return this[onLine];
+ }
+ set onLine(value) {
+ super.onLine = value;
+ }
};
+ const onLine = Symbol(html$.NavigatorOnLine.name + "." + 'onLine'.toString());
dart.setSignature(html$.NavigatorOnLine, {
constructors: () => ({_: dart.definiteFunctionType(html$.NavigatorOnLine, [])}),
fields: () => ({onLine: core.bool})
@@ -65121,14 +65729,14 @@
if (index == this.length) {
this[_this][dartx.append](node);
} else {
- this[_this][dartx.insertBefore](node, this.get(index));
+ this[_this][dartx.insertBefore](node, this._get(index));
}
}
insertAll(index, iterable) {
if (index == this.length) {
this.addAll(iterable);
} else {
- let item = this.get(index);
+ let item = this._get(index);
this[_this][dartx.insertAllBefore](iterable, item);
}
}
@@ -65143,7 +65751,7 @@
return result;
}
removeAt(index) {
- let result = this.get(index);
+ let result = this._get(index);
if (result != null) {
this[_this][_removeChild](result);
}
@@ -65175,8 +65783,8 @@
clear() {
this[_this][_clearChildren]();
}
- set(index, value) {
- this[_this][_replaceChild](value, this.get(index));
+ _set(index, value) {
+ this[_this][_replaceChild](value, this._get(index));
return value;
}
get iterator() {
@@ -65204,8 +65812,8 @@
set length(value) {
dart.throw(new core.UnsupportedError("Cannot set length on immutable List."));
}
- get(index) {
- return this[_this][dartx.childNodes][dartx.get](index);
+ _get(index) {
+ return this[_this][dartx.childNodes][dartx._get](index);
}
get rawList() {
return this[_this][dartx.childNodes];
@@ -65236,11 +65844,11 @@
[_filter$]: dart.definiteFunctionType(dart.void, [NodeTobool(), core.bool]),
removeWhere: dart.definiteFunctionType(dart.void, [NodeTobool()]),
retainWhere: dart.definiteFunctionType(dart.void, [NodeTobool()]),
- set: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
sort: dart.definiteFunctionType(dart.void, [], [ComparatorOfNode()]),
setRange: dart.definiteFunctionType(dart.void, [core.int, core.int, IterableOfNode()], [core.int]),
fillRange: dart.definiteFunctionType(dart.void, [core.int, core.int], [html$.Node]),
- get: dart.definiteFunctionType(html$.Node, [core.int])
+ _get: dart.definiteFunctionType(html$.Node, [core.int])
})
});
dart.defineExtensionMembers(html$._ChildNodeListLazy, [
@@ -65255,12 +65863,12 @@
'removeWhere',
'retainWhere',
'clear',
- 'set',
+ '_set',
'sort',
'shuffle',
'setRange',
'fillRange',
- 'get',
+ '_get',
'first',
'last',
'single',
@@ -65359,8 +65967,8 @@
dart.registerExtension(dart.global.NodeIterator, html$.NodeIterator);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -65374,11 +65982,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -65407,7 +66015,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[_item](index) {
return this.item(index);
@@ -65424,8 +66032,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Node, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
+ [dartx._get]: dart.definiteFunctionType(html$.Node, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Node, [core.int]),
[_item]: dart.definiteFunctionType(html$.Node, [core.int])
})
@@ -65496,11 +66104,11 @@
let tag = opts && 'tag' in opts ? opts.tag : null;
let icon = opts && 'icon' in opts ? opts.icon : null;
let parsedOptions = dart.map();
- if (dir != null) parsedOptions[dartx.set]('dir', dir);
- if (body != null) parsedOptions[dartx.set]('body', body);
- if (lang != null) parsedOptions[dartx.set]('lang', lang);
- if (tag != null) parsedOptions[dartx.set]('tag', tag);
- if (icon != null) parsedOptions[dartx.set]('icon', icon);
+ if (dir != null) parsedOptions[dartx._set]('dir', dir);
+ if (body != null) parsedOptions[dartx._set]('body', body);
+ if (lang != null) parsedOptions[dartx._set]('lang', lang);
+ if (tag != null) parsedOptions[dartx._set]('tag', tag);
+ if (icon != null) parsedOptions[dartx._set]('icon', icon);
return html$.Notification._factoryNotification(title, parsedOptions);
}
static _() {
@@ -67041,8 +67649,8 @@
dart.registerExtension(dart.global.Plugin, html$.Plugin);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -67059,11 +67667,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -67092,7 +67700,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -67115,8 +67723,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Plugin, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Plugin]),
+ [dartx._get]: dart.definiteFunctionType(html$.Plugin, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Plugin]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Plugin, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.Plugin, [core.int]),
[dartx.namedItem]: dart.definiteFunctionType(html$.Plugin, [core.String]),
@@ -69563,7 +70171,7 @@
let options = this[dartx.options][dartx.where](dart.fn(o => o[dartx.selected], OptionElementTobool()))[dartx.toList]();
return new (UnmodifiableListViewOfOptionElement())(options);
} else {
- return JSArrayOfOptionElement().of([this[dartx.options][dartx.get](this[dartx.selectedIndex])]);
+ return JSArrayOfOptionElement().of([this[dartx.options][dartx._get](this[dartx.selectedIndex])]);
}
}
};
@@ -70531,8 +71139,8 @@
dart.registerExtension(dart.global.SourceBuffer, html$.SourceBuffer);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -70547,11 +71155,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -70580,7 +71188,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -70597,8 +71205,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.SourceBuffer, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.SourceBuffer]),
+ [dartx._get]: dart.definiteFunctionType(html$.SourceBuffer, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.SourceBuffer]),
[dartx.elementAt]: dart.definiteFunctionType(html$.SourceBuffer, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.SourceBuffer, [core.int])
})
@@ -70768,8 +71376,8 @@
dart.registerExtension(dart.global.SpeechGrammar, html$.SpeechGrammar);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -70792,11 +71400,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -70825,7 +71433,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.addFromString](string, weight) {
return this.addFromString(string, weight);
@@ -70851,8 +71459,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.SpeechGrammar, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.SpeechGrammar]),
+ [dartx._get]: dart.definiteFunctionType(html$.SpeechGrammar, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.SpeechGrammar]),
[dartx.elementAt]: dart.definiteFunctionType(html$.SpeechGrammar, [core.int]),
[dartx.addFromString]: dart.definiteFunctionType(dart.void, [core.String], [core.num]),
[dartx.addFromUri]: dart.definiteFunctionType(dart.void, [core.String], [core.num]),
@@ -71544,8 +72152,8 @@
'addAll',
'containsValue',
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -71559,7 +72167,7 @@
html$.Storage = class Storage extends _interceptors.Interceptor {
[dartx.addAll](other) {
other[dartx.forEach](dart.fn((k, v) => {
- this[dartx.set](k, v);
+ this[dartx._set](k, v);
}, StringAndStringTovoid$()));
}
[dartx.containsValue](value) {
@@ -71568,19 +72176,19 @@
[dartx.containsKey](key) {
return this[_getItem](core.String._check(key)) != null;
}
- [dartx.get](key) {
+ [dartx._get](key) {
return this[_getItem](core.String._check(key));
}
- [dartx.set](key, value) {
+ [dartx._set](key, value) {
this[_setItem](key, value);
return value;
}
[dartx.putIfAbsent](key, ifAbsent) {
- if (!dart.test(this[dartx.containsKey](key))) this[dartx.set](key, ifAbsent());
- return this[dartx.get](key);
+ if (!dart.test(this[dartx.containsKey](key))) this[dartx._set](key, ifAbsent());
+ return this[dartx._get](key);
}
[dartx.remove](key) {
- let value = this[dartx.get](key);
+ let value = this[dartx._get](key);
this[_removeItem](core.String._check(key));
return value;
}
@@ -71591,7 +72199,7 @@
for (let i = 0; true; i++) {
let key = this[_key](i);
if (key == null) return;
- f(key, this[dartx.get](key));
+ f(key, this[dartx._get](key));
}
}
get [dartx.keys]() {
@@ -71659,8 +72267,8 @@
[dartx.addAll]: dart.definiteFunctionType(dart.void, [MapOfString$String()]),
[dartx.containsValue]: dart.definiteFunctionType(core.bool, [core.Object]),
[dartx.containsKey]: dart.definiteFunctionType(core.bool, [core.Object]),
- [dartx.get]: dart.definiteFunctionType(core.String, [core.Object]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.Object]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.String, core.String]),
[dartx.putIfAbsent]: dart.definiteFunctionType(core.String, [core.String, VoidToString()]),
[dartx.remove]: dart.definiteFunctionType(core.String, [core.Object]),
[dartx.clear]: dart.definiteFunctionType(dart.void, []),
@@ -72989,8 +73597,8 @@
dart.registerExtension(dart.global.TextTrackCue, html$.TextTrackCue);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -73006,11 +73614,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -73039,7 +73647,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.getCueById](id) {
return this.getCueById(id);
@@ -73059,8 +73667,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.TextTrackCue, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.TextTrackCue]),
+ [dartx._get]: dart.definiteFunctionType(html$.TextTrackCue, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.TextTrackCue]),
[dartx.elementAt]: dart.definiteFunctionType(html$.TextTrackCue, [core.int]),
[dartx.getCueById]: dart.definiteFunctionType(html$.TextTrackCue, [core.String]),
[dartx.item]: dart.definiteFunctionType(html$.TextTrackCue, [core.int])
@@ -73069,8 +73677,8 @@
dart.registerExtension(dart.global.TextTrackCueList, html$.TextTrackCueList);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -73088,11 +73696,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -73121,7 +73729,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.getTrackById](id) {
return this.getTrackById(id);
@@ -73149,8 +73757,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.TextTrack, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.TextTrack]),
+ [dartx._get]: dart.definiteFunctionType(html$.TextTrack, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.TextTrack]),
[dartx.elementAt]: dart.definiteFunctionType(html$.TextTrack, [core.int]),
[dartx.getTrackById]: dart.definiteFunctionType(html$.TextTrack, [core.String]),
[dartx.item]: dart.definiteFunctionType(html$.TextTrack, [core.int])
@@ -73435,8 +74043,8 @@
dart.registerExtension(dart.global.TouchEvent, html$.TouchEvent);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -73457,11 +74065,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -73490,7 +74098,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -73510,8 +74118,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Touch, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Touch]),
+ [dartx._get]: dart.definiteFunctionType(html$.Touch, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Touch]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Touch, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.Touch, [core.int])
}),
@@ -74063,7 +74671,84 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get hash() {
+ return this[hash];
+ }
+ set hash(value) {
+ this[hash] = value;
+ }
+ get host() {
+ return this[host];
+ }
+ set host(value) {
+ this[host] = value;
+ }
+ get hostname() {
+ return this[hostname];
+ }
+ set hostname(value) {
+ this[hostname] = value;
+ }
+ get href() {
+ return this[href];
+ }
+ set href(value) {
+ this[href] = value;
+ }
+ get origin() {
+ return this[origin];
+ }
+ set origin(value) {
+ super.origin = value;
+ }
+ get password() {
+ return this[password];
+ }
+ set password(value) {
+ this[password] = value;
+ }
+ get pathname() {
+ return this[pathname];
+ }
+ set pathname(value) {
+ this[pathname] = value;
+ }
+ get port() {
+ return this[port];
+ }
+ set port(value) {
+ this[port] = value;
+ }
+ get protocol() {
+ return this[protocol];
+ }
+ set protocol(value) {
+ this[protocol] = value;
+ }
+ get search() {
+ return this[search];
+ }
+ set search(value) {
+ this[search] = value;
+ }
+ get username() {
+ return this[username];
+ }
+ set username(value) {
+ this[username] = value;
+ }
};
+ const hash = Symbol(html$.UrlUtils.name + "." + 'hash'.toString());
+ const host = Symbol(html$.UrlUtils.name + "." + 'host'.toString());
+ const hostname = Symbol(html$.UrlUtils.name + "." + 'hostname'.toString());
+ const href = Symbol(html$.UrlUtils.name + "." + 'href'.toString());
+ const origin = Symbol(html$.UrlUtils.name + "." + 'origin'.toString());
+ const password = Symbol(html$.UrlUtils.name + "." + 'password'.toString());
+ const pathname = Symbol(html$.UrlUtils.name + "." + 'pathname'.toString());
+ const port = Symbol(html$.UrlUtils.name + "." + 'port'.toString());
+ const protocol = Symbol(html$.UrlUtils.name + "." + 'protocol'.toString());
+ const search = Symbol(html$.UrlUtils.name + "." + 'search'.toString());
+ const username = Symbol(html$.UrlUtils.name + "." + 'username'.toString());
dart.setSignature(html$.UrlUtils, {
constructors: () => ({_: dart.definiteFunctionType(html$.UrlUtils, [])}),
fields: () => ({
@@ -74118,7 +74803,70 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get hash() {
+ return this[hash$];
+ }
+ set hash(value) {
+ super.hash = value;
+ }
+ get host() {
+ return this[host$];
+ }
+ set host(value) {
+ super.host = value;
+ }
+ get hostname() {
+ return this[hostname$];
+ }
+ set hostname(value) {
+ super.hostname = value;
+ }
+ get href() {
+ return this[href$];
+ }
+ set href(value) {
+ super.href = value;
+ }
+ get origin() {
+ return this[origin$];
+ }
+ set origin(value) {
+ super.origin = value;
+ }
+ get pathname() {
+ return this[pathname$];
+ }
+ set pathname(value) {
+ super.pathname = value;
+ }
+ get port() {
+ return this[port$];
+ }
+ set port(value) {
+ super.port = value;
+ }
+ get protocol() {
+ return this[protocol$];
+ }
+ set protocol(value) {
+ super.protocol = value;
+ }
+ get search() {
+ return this[search$];
+ }
+ set search(value) {
+ super.search = value;
+ }
};
+ const hash$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'hash'.toString());
+ const host$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'host'.toString());
+ const hostname$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'hostname'.toString());
+ const href$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'href'.toString());
+ const origin$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'origin'.toString());
+ const pathname$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'pathname'.toString());
+ const port$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'port'.toString());
+ const protocol$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'protocol'.toString());
+ const search$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'search'.toString());
dart.setSignature(html$.UrlUtilsReadOnly, {
constructors: () => ({_: dart.definiteFunctionType(html$.UrlUtilsReadOnly, [])}),
fields: () => ({
@@ -77185,8 +77933,8 @@
});
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77201,11 +77949,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.item](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77234,7 +77982,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__getter__](index) {
return this.__getter__(index);
@@ -77254,8 +78002,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, RectangleOfnum()]),
+ [dartx._get]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, RectangleOfnum()]),
[dartx.elementAt]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
[__getter__]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
[dartx.item]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int])
@@ -77265,8 +78013,8 @@
dart.registerExtension(dart.global.DOMRectList, html$._ClientRectList);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77281,11 +78029,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77314,7 +78062,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -77331,8 +78079,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.CssRule, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.CssRule]),
+ [dartx._get]: dart.definiteFunctionType(html$.CssRule, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.CssRule]),
[dartx.elementAt]: dart.definiteFunctionType(html$.CssRule, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.CssRule, [core.int])
})
@@ -77518,8 +78266,8 @@
dart.registerExtension(dart.global.FileWriterSync, html$._FileWriterSync);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77534,11 +78282,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77567,7 +78315,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -77584,8 +78332,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Gamepad, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Gamepad]),
+ [dartx._get]: dart.definiteFunctionType(html$.Gamepad, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Gamepad]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Gamepad, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.Gamepad, [core.int])
})
@@ -77703,8 +78451,8 @@
dart.registerExtension(dart.global.HTMLMarqueeElement, html$._HTMLMarqueeElement);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77725,11 +78473,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77758,7 +78506,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.getNamedItem](name) {
return this.getNamedItem(name);
@@ -77793,8 +78541,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Node, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
+ [dartx._get]: dart.definiteFunctionType(html$.Node, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Node, [core.int]),
[dartx.getNamedItem]: dart.definiteFunctionType(html$._Attr, [core.String]),
[dartx.getNamedItemNS]: dart.definiteFunctionType(html$._Attr, [core.String, core.String]),
@@ -77937,8 +78685,8 @@
dart.registerExtension(dart.global.ServiceWorker, html$._ServiceWorker);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77953,11 +78701,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77986,7 +78734,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -78003,8 +78751,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.SpeechRecognitionResult, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.SpeechRecognitionResult]),
+ [dartx._get]: dart.definiteFunctionType(html$.SpeechRecognitionResult, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.SpeechRecognitionResult]),
[dartx.elementAt]: dart.definiteFunctionType(html$.SpeechRecognitionResult, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.SpeechRecognitionResult, [core.int])
})
@@ -78012,8 +78760,8 @@
dart.registerExtension(dart.global.SpeechRecognitionResultList, html$._SpeechRecognitionResultList);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -78028,11 +78776,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -78061,7 +78809,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__getter__](name) {
return this.__getter__(name);
@@ -78081,8 +78829,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.StyleSheet, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.StyleSheet]),
+ [dartx._get]: dart.definiteFunctionType(html$.StyleSheet, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.StyleSheet]),
[dartx.elementAt]: dart.definiteFunctionType(html$.StyleSheet, [core.int]),
[__getter__]: dart.definiteFunctionType(html$.CssStyleSheet, [core.String]),
[dartx.item]: dart.definiteFunctionType(html$.StyleSheet, [core.int])
@@ -78172,7 +78920,7 @@
}
addAll(other) {
other[dartx.forEach](dart.fn((k, v) => {
- this.set(k, v);
+ this._set(k, v);
}, StringAndStringTovoid$()));
}
containsValue(value) {
@@ -78185,9 +78933,9 @@
}
putIfAbsent(key, ifAbsent) {
if (!dart.test(this[dartx.containsKey](key))) {
- this.set(key, ifAbsent());
+ this._set(key, ifAbsent());
}
- return this.get(key);
+ return this._get(key);
}
clear() {
for (let key of this.keys) {
@@ -78196,7 +78944,7 @@
}
forEach(f) {
for (let key of this.keys) {
- let value = this.get(key);
+ let value = this._get(key);
f(key, value);
}
}
@@ -78204,7 +78952,7 @@
let attributes = this[_element$][_attributes$];
let keys = JSArrayOfString().of([]);
for (let i = 0, len = attributes[dartx.length]; i < dart.notNull(len); i++) {
- let attr = html$._Attr._check(attributes[dartx.get](i));
+ let attr = html$._Attr._check(attributes[dartx._get](i));
if (dart.test(this[_matches](attr))) {
keys[dartx.add](attr[dartx.name]);
}
@@ -78215,7 +78963,7 @@
let attributes = this[_element$][_attributes$];
let values = JSArrayOfString().of([]);
for (let i = 0, len = attributes[dartx.length]; i < dart.notNull(len); i++) {
- let attr = html$._Attr._check(attributes[dartx.get](i));
+ let attr = html$._Attr._check(attributes[dartx._get](i));
if (dart.test(this[_matches](attr))) {
values[dartx.add](attr[dartx.value]);
}
@@ -78265,10 +79013,10 @@
containsKey(key) {
return this[_element$][_hasAttribute](core.String._check(key));
}
- get(key) {
+ _get(key) {
return this[_element$][dartx.getAttribute](core.String._check(key));
}
- set(key, value) {
+ _set(key, value) {
this[_element$][dartx.setAttribute](key, value);
return value;
}
@@ -78289,16 +79037,16 @@
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
- get: dart.definiteFunctionType(core.String, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ _get: dart.definiteFunctionType(core.String, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
remove: dart.definiteFunctionType(core.String, [core.Object]),
[_matches]: dart.definiteFunctionType(core.bool, [html$.Node])
})
});
dart.defineExtensionMembers(html$._ElementAttributeMap, [
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'remove',
'length'
]);
@@ -78311,15 +79059,15 @@
containsKey(key) {
return this[_element$][_hasAttributeNS](this[_namespace], core.String._check(key));
}
- get(key) {
+ _get(key) {
return this[_element$][dartx.getAttributeNS](this[_namespace], core.String._check(key));
}
- set(key, value) {
+ _set(key, value) {
this[_element$][dartx.setAttributeNS](this[_namespace], key, value);
return value;
}
remove(key) {
- let value = this.get(key);
+ let value = this._get(key);
this[_element$][_removeAttributeNS](this[_namespace], core.String._check(key));
return value;
}
@@ -78336,16 +79084,16 @@
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
- get: dart.definiteFunctionType(core.String, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ _get: dart.definiteFunctionType(core.String, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
remove: dart.definiteFunctionType(core.String, [core.Object]),
[_matches]: dart.definiteFunctionType(core.bool, [html$.Node])
})
});
dart.defineExtensionMembers(html$._NamespacedAttributeMap, [
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'remove',
'length'
]);
@@ -78359,7 +79107,7 @@
}
addAll(other) {
other[dartx.forEach](dart.fn((k, v) => {
- this.set(k, v);
+ this._set(k, v);
}, StringAndStringTovoid$()));
}
containsValue(value) {
@@ -78368,11 +79116,11 @@
containsKey(key) {
return this[_attributes$][dartx.containsKey](this[_attr](core.String._check(key)));
}
- get(key) {
- return this[_attributes$][dartx.get](this[_attr](core.String._check(key)));
+ _get(key) {
+ return this[_attributes$][dartx._get](this[_attr](core.String._check(key)));
}
- set(key, value) {
- this[_attributes$][dartx.set](this[_attr](key), value);
+ _set(key, value) {
+ this[_attributes$][dartx._set](this[_attr](key), value);
return value;
}
putIfAbsent(key, ifAbsent) {
@@ -78434,9 +79182,9 @@
let segments = hyphenedName[dartx.split]('-');
let start = dart.test(startUppercase) ? 0 : 1;
for (let i = start; i < dart.notNull(segments[dartx.length]); i++) {
- let segment = segments[dartx.get](i);
+ let segment = segments[dartx._get](i);
if (dart.notNull(segment[dartx.length]) > 0) {
- segments[dartx.set](i, dart.str`${segment[dartx.get](0)[dartx.toUpperCase]()}${segment[dartx.substring](1)}`);
+ segments[dartx._set](i, dart.str`${segment[dartx._get](0)[dartx.toUpperCase]()}${segment[dartx.substring](1)}`);
}
}
return segments[dartx.join]('');
@@ -78444,8 +79192,8 @@
[_toHyphenedName](word) {
let sb = new core.StringBuffer();
for (let i = 0; i < dart.notNull(word[dartx.length]); i++) {
- let lower = word[dartx.get](i)[dartx.toLowerCase]();
- if (word[dartx.get](i) != lower && i > 0) sb.write('-');
+ let lower = word[dartx._get](i)[dartx.toLowerCase]();
+ if (word[dartx._get](i) != lower && i > 0) sb.write('-');
sb.write(lower);
}
return sb.toString();
@@ -78466,8 +79214,8 @@
addAll: dart.definiteFunctionType(dart.void, [MapOfString$String()]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
- get: dart.definiteFunctionType(core.String, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ _get: dart.definiteFunctionType(core.String, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
putIfAbsent: dart.definiteFunctionType(core.String, [core.String, VoidToString()]),
remove: dart.definiteFunctionType(core.String, [core.Object]),
clear: dart.definiteFunctionType(dart.void, []),
@@ -78483,8 +79231,8 @@
'addAll',
'containsValue',
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -80030,7 +80778,7 @@
add(stream) {
StreamOfT()._check(stream);
if (dart.test(this[_subscriptions][dartx.containsKey](stream))) return;
- this[_subscriptions][dartx.set](stream, stream.listen(dart.bind(this[_controller$0], 'add'), {onError: dart.bind(this[_controller$0], 'addError'), onDone: dart.fn(() => this.remove(stream), VoidTovoid$())}));
+ this[_subscriptions][dartx._set](stream, stream.listen(dart.bind(this[_controller$0], 'add'), {onError: dart.bind(this[_controller$0], 'addError'), onDone: dart.fn(() => this.remove(stream), VoidTovoid$())}));
}
remove(stream) {
StreamOfT()._check(stream);
@@ -80114,10 +80862,10 @@
this.uriPolicy = uriPolicy != null ? uriPolicy : html$.UriPolicy.new();
if (dart.test(html$._Html5NodeValidator._attributeValidators[dartx.isEmpty])) {
for (let attr of html$._Html5NodeValidator._standardAttributes) {
- html$._Html5NodeValidator._attributeValidators[dartx.set](attr, html$._Html5NodeValidator._standardAttributeValidator);
+ html$._Html5NodeValidator._attributeValidators[dartx._set](attr, html$._Html5NodeValidator._standardAttributeValidator);
}
for (let attr of html$._Html5NodeValidator._uriAttributes) {
- html$._Html5NodeValidator._attributeValidators[dartx.set](attr, html$._Html5NodeValidator._uriAttributeValidator);
+ html$._Html5NodeValidator._attributeValidators[dartx._set](attr, html$._Html5NodeValidator._uriAttributeValidator);
}
}
}
@@ -80126,9 +80874,9 @@
}
allowsAttribute(element, attributeName, value) {
let tagName = html$.Element._safeTagName(element);
- let validator = html$._Html5NodeValidator._attributeValidators[dartx.get](dart.str`${tagName}::${attributeName}`);
+ let validator = html$._Html5NodeValidator._attributeValidators[dartx._get](dart.str`${tagName}::${attributeName}`);
if (validator == null) {
- validator = html$._Html5NodeValidator._attributeValidators[dartx.get](dart.str`*::${attributeName}`);
+ validator = html$._Html5NodeValidator._attributeValidators[dartx._get](dart.str`*::${attributeName}`);
}
if (validator == null) {
return false;
@@ -80959,7 +81707,7 @@
if (prevEvent[_shadowCharCode] == event[dartx.charCode]) {
return prevEvent.keyCode;
}
- if ((dart.test(event[dartx.shiftKey]) || dart.test(this[_capsLockOn])) && dart.notNull(event[dartx.charCode]) >= dart.notNull("A"[dartx.codeUnits][dartx.get](0)) && dart.notNull(event[dartx.charCode]) <= dart.notNull("Z"[dartx.codeUnits][dartx.get](0)) && dart.notNull(event[dartx.charCode]) + dart.notNull(html$._KeyboardEventHandler._ROMAN_ALPHABET_OFFSET) == prevEvent[_shadowCharCode]) {
+ if ((dart.test(event[dartx.shiftKey]) || dart.test(this[_capsLockOn])) && dart.notNull(event[dartx.charCode]) >= dart.notNull("A"[dartx.codeUnits][dartx._get](0)) && dart.notNull(event[dartx.charCode]) <= dart.notNull("Z"[dartx.codeUnits][dartx._get](0)) && dart.notNull(event[dartx.charCode]) + dart.notNull(html$._KeyboardEventHandler._ROMAN_ALPHABET_OFFSET) == prevEvent[_shadowCharCode]) {
return prevEvent.keyCode;
}
}
@@ -81157,7 +81905,7 @@
}
e[_shadowKeyCode] = this[_determineKeyCodeForKeypress](e);
if (e[_shadowKeyIdentifier] != null && dart.test(html$._KeyboardEventHandler._keyIdentifier[dartx.containsKey](e[_shadowKeyIdentifier]))) {
- e[_shadowKeyCode] = html$._KeyboardEventHandler._keyIdentifier[dartx.get](e[_shadowKeyIdentifier]);
+ e[_shadowKeyCode] = html$._KeyboardEventHandler._keyIdentifier[dartx._get](e[_shadowKeyIdentifier]);
}
e[_shadowAltKey] = this[_keyDownList][dartx.any](dart.fn(element => element.altKey, KeyEventTobool()));
this[_stream$].add(e);
@@ -81212,7 +81960,7 @@
html$._KeyboardEventHandler._keyIdentifier = dart.const(dart.map({Up: html$.KeyCode.UP, Down: html$.KeyCode.DOWN, Left: html$.KeyCode.LEFT, Right: html$.KeyCode.RIGHT, Enter: html$.KeyCode.ENTER, F1: html$.KeyCode.F1, F2: html$.KeyCode.F2, F3: html$.KeyCode.F3, F4: html$.KeyCode.F4, F5: html$.KeyCode.F5, F6: html$.KeyCode.F6, F7: html$.KeyCode.F7, F8: html$.KeyCode.F8, F9: html$.KeyCode.F9, F10: html$.KeyCode.F10, F11: html$.KeyCode.F11, F12: html$.KeyCode.F12, 'U+007F': html$.KeyCode.DELETE, Home: html$.KeyCode.HOME, End: html$.KeyCode.END, PageUp: html$.KeyCode.PAGE_UP, PageDown: html$.KeyCode.PAGE_DOWN, Insert: html$.KeyCode.INSERT}, core.String, core.int));
dart.defineLazy(html$._KeyboardEventHandler, {
get _ROMAN_ALPHABET_OFFSET() {
- return dart.notNull("a"[dartx.codeUnits][dartx.get](0)) - dart.notNull("A"[dartx.codeUnits][dartx.get](0));
+ return dart.notNull("a"[dartx.codeUnits][dartx._get](0)) - dart.notNull("A"[dartx.codeUnits][dartx._get](0));
}
});
html$.KeyboardEventStream = class KeyboardEventStream extends core.Object {
@@ -81430,7 +82178,7 @@
}
allowsElement(element) {
if (dart.test(this.allowTypeExtension)) {
- let isAttr = element[dartx.attributes][dartx.get]('is');
+ let isAttr = element[dartx.attributes][dartx._get]('is');
if (isAttr != null) {
return dart.test(this.allowedElements.contains(isAttr[dartx.toUpperCase]())) && dart.test(this.allowedElements.contains(html$.Element._safeTagName(element)));
}
@@ -81467,7 +82215,7 @@
if (attributeName == 'template' && value == "") {
return true;
}
- if (element[dartx.attributes][dartx.get]('template') == "") {
+ if (element[dartx.attributes][dartx._get]('template') == "") {
return this[_templateAttrs].contains(attributeName);
}
return false;
@@ -81542,12 +82290,12 @@
clear() {
this[_list$][dartx.clear]();
}
- get(index) {
- return html$._downcast(html$.Node, E)(this[_list$][dartx.get](index));
+ _get(index) {
+ return html$._downcast(html$.Node, E)(this[_list$][dartx._get](index));
}
- set(index, value) {
+ _set(index, value) {
E._check(value);
- this[_list$][dartx.set](index, value);
+ this[_list$][dartx._set](index, value);
return value;
}
set length(newLength) {
@@ -81605,8 +82353,8 @@
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
add: dart.definiteFunctionType(dart.void, [E]),
- get: dart.definiteFunctionType(E, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _get: dart.definiteFunctionType(E, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
sort: dart.definiteFunctionType(dart.void, [], [EAndEToint()]),
insert: dart.definiteFunctionType(dart.void, [core.int, E]),
removeAt: dart.definiteFunctionType(E, [core.int]),
@@ -81619,8 +82367,8 @@
'add',
'remove',
'clear',
- 'get',
- 'set',
+ '_get',
+ '_set',
'sort',
'indexOf',
'lastIndexOf',
@@ -81701,7 +82449,7 @@
moveNext() {
let nextPosition = dart.notNull(this[_position$0]) + 1;
if (nextPosition < dart.notNull(this[_length$2])) {
- this[_current$4] = this[_array][dartx.get](nextPosition);
+ this[_current$4] = this[_array][dartx._get](nextPosition);
this[_position$0] = nextPosition;
return true;
}
@@ -81741,7 +82489,7 @@
moveNext() {
let nextPosition = dart.notNull(this[_position$0]) + 1;
if (nextPosition < dart.notNull(this[_array][dartx.length])) {
- this[_current$4] = this[_array][dartx.get](nextPosition);
+ this[_current$4] = this[_array][dartx._get](nextPosition);
this[_position$0] = nextPosition;
return true;
}
@@ -82326,9 +83074,9 @@
}
let keys = attrs[dartx.keys][dartx.toList]();
for (let i = dart.notNull(attrs[dartx.length]) - 1; i >= 0; --i) {
- let name = keys[dartx.get](i);
- if (!dart.test(this.validator.allowsAttribute(element, core.String._check(dart.dsend(name, 'toLowerCase')), core.String._check(attrs[dartx.get](name))))) {
- html$.window[dartx.console].warn('Removing disallowed attribute ' + dart.str`<${tag} ${name}="${attrs[dartx.get](name)}">`);
+ let name = keys[dartx._get](i);
+ if (!dart.test(this.validator.allowsAttribute(element, core.String._check(dart.dsend(name, 'toLowerCase')), core.String._check(attrs[dartx._get](name))))) {
+ html$.window[dartx.console].warn('Removing disallowed attribute ' + dart.str`<${tag} ${name}="${attrs[dartx._get](name)}">`);
attrs[dartx.remove](name);
}
}
@@ -82395,17 +83143,17 @@
findSlot(value) {
let length = this.values[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (core.identical(this.values[dartx.get](i), value)) return i;
+ if (core.identical(this.values[dartx._get](i), value)) return i;
}
this.values[dartx.add](value);
this.copies[dartx.add](null);
return length;
}
readSlot(i) {
- return this.copies[dartx.get](i);
+ return this.copies[dartx._get](i);
}
writeSlot(i, x) {
- this.copies[dartx.set](i, x);
+ this.copies[dartx._set](i, x);
}
cleanupSlots() {}
walk(e) {
@@ -82450,7 +83198,7 @@
let copy = this.newJsList(length);
this.writeSlot(slot, copy);
for (; i < dart.notNull(length); i++) {
- dart.dsetindex(copy, i, this.walk(e[dartx.get](i)));
+ dart.dsetindex(copy, i, this.walk(e[dartx._get](i)));
}
return copy;
}
@@ -82484,17 +83232,17 @@
findSlot(value) {
let length = this.values[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (dart.test(this.identicalInJs(this.values[dartx.get](i), value))) return i;
+ if (dart.test(this.identicalInJs(this.values[dartx._get](i), value))) return i;
}
this.values[dartx.add](value);
this.copies[dartx.add](null);
return length;
}
readSlot(i) {
- return this.copies[dartx.get](i);
+ return this.copies[dartx._get](i);
}
writeSlot(i, x) {
- this.copies[dartx.set](i, x);
+ this.copies[dartx._set](i, x);
}
walk(e) {
if (e == null) return e;
@@ -82627,7 +83375,7 @@
let dict = dart.map();
let keys = Object.getOwnPropertyNames(object);
for (let key of core.Iterable._check(keys)) {
- dict[dartx.set](key, object[key]);
+ dict[dartx._set](key, object[key]);
}
return dict;
};
@@ -82863,8 +83611,8 @@
forEach(f) {
this[_filtered][dartx.forEach](f);
}
- set(index, value) {
- this.get(index)[dartx.replaceWith](value);
+ _set(index, value) {
+ this._get(index)[dartx.replaceWith](value);
return value;
}
set length(newLength) {
@@ -82937,7 +83685,7 @@
}
}
removeAt(index) {
- let result = this.get(index);
+ let result = this._get(index);
result[dartx.remove]();
return result;
}
@@ -82953,7 +83701,7 @@
get length() {
return this[_iterable$0][dartx.length];
}
- get(index) {
+ _get(index) {
return this[_iterable$0][dartx.elementAt](index);
}
get iterator() {
@@ -82982,7 +83730,7 @@
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
forEach: dart.definiteFunctionType(dart.void, [ElementTovoid()]),
- set: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
add: dart.definiteFunctionType(dart.void, [html$.Element]),
addAll: dart.definiteFunctionType(dart.void, [IterableOfElement()]),
sort: dart.definiteFunctionType(dart.void, [], [ElementAndElementToint()]),
@@ -82993,12 +83741,12 @@
insert: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
insertAll: dart.definiteFunctionType(dart.void, [core.int, IterableOfElement()]),
removeAt: dart.definiteFunctionType(html$.Element, [core.int]),
- get: dart.definiteFunctionType(html$.Element, [core.int])
+ _get: dart.definiteFunctionType(html$.Element, [core.int])
})
});
dart.defineExtensionMembers(html_common.FilteredElementList, [
'forEach',
- 'set',
+ '_set',
'add',
'addAll',
'contains',
@@ -83013,7 +83761,7 @@
'insertAll',
'removeAt',
'remove',
- 'get',
+ '_get',
'length',
'reversed',
'length',
@@ -83028,7 +83776,7 @@
startIndex = 0;
}
for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dart.notNull(i) + 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -83042,7 +83790,7 @@
startIndex = dart.notNull(a[dartx.length]) - 1;
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -83053,7 +83801,7 @@
if (dart.notNull(end) < dart.notNull(start)) dart.throw(new core.RangeError.value(end));
if (dart.notNull(end) > dart.notNull(a[dartx.length])) dart.throw(new core.RangeError.value(end));
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- accumulator[dartx.add](a[dartx.get](i));
+ accumulator[dartx.add](a[dartx._get](i));
}
return accumulator;
}
@@ -86275,7 +87023,42 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get height() {
+ return this[height$];
+ }
+ set height(value) {
+ super.height = value;
+ }
+ get result() {
+ return this[result];
+ }
+ set result(value) {
+ super.result = value;
+ }
+ get width() {
+ return this[width$];
+ }
+ set width(value) {
+ super.width = value;
+ }
+ get x() {
+ return this[x];
+ }
+ set x(value) {
+ super.x = value;
+ }
+ get y() {
+ return this[y];
+ }
+ set y(value) {
+ super.y = value;
+ }
};
+ const height$ = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'height'.toString());
+ const result = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'result'.toString());
+ const width$ = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'width'.toString());
+ const x = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'x'.toString());
+ const y = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'y'.toString());
dart.setSignature(svg$.FilterPrimitiveStandardAttributes, {
constructors: () => ({_: dart.definiteFunctionType(svg$.FilterPrimitiveStandardAttributes, [])}),
fields: () => ({
@@ -86301,7 +87084,21 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get preserveAspectRatio() {
+ return this[preserveAspectRatio];
+ }
+ set preserveAspectRatio(value) {
+ super.preserveAspectRatio = value;
+ }
+ get viewBox() {
+ return this[viewBox];
+ }
+ set viewBox(value) {
+ super.viewBox = value;
+ }
};
+ const preserveAspectRatio = Symbol(svg$.FitToViewBox.name + "." + 'preserveAspectRatio'.toString());
+ const viewBox = Symbol(svg$.FitToViewBox.name + "." + 'viewBox'.toString());
dart.setSignature(svg$.FitToViewBox, {
constructors: () => ({_: dart.definiteFunctionType(svg$.FitToViewBox, [])}),
fields: () => ({
@@ -86524,8 +87321,8 @@
const __setter__$ = Symbol('__setter__');
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -86550,11 +87347,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -86583,7 +87380,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -86622,8 +87419,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg$.Length, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Length]),
+ [dartx._get]: dart.definiteFunctionType(svg$.Length, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Length]),
[dartx.elementAt]: dart.definiteFunctionType(svg$.Length, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, svg$.Length]),
[dartx.appendItem]: dart.definiteFunctionType(svg$.Length, [svg$.Length]),
@@ -87130,8 +87927,8 @@
dart.registerExtension(dart.global.SVGNumber, svg$.Number);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -87156,11 +87953,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -87189,7 +87986,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -87228,8 +88025,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg$.Number, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Number]),
+ [dartx._get]: dart.definiteFunctionType(svg$.Number, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Number]),
[dartx.elementAt]: dart.definiteFunctionType(svg$.Number, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, svg$.Number]),
[dartx.appendItem]: dart.definiteFunctionType(svg$.Number, [svg$.Number]),
@@ -88115,8 +88912,8 @@
dart.registerExtension(dart.global.SVGPathSegLinetoVerticalRel, svg$.PathSegLinetoVerticalRel);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -88141,11 +88938,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -88174,7 +88971,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -88213,8 +89010,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg$.PathSeg, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg$.PathSeg]),
+ [dartx._get]: dart.definiteFunctionType(svg$.PathSeg, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg$.PathSeg]),
[dartx.elementAt]: dart.definiteFunctionType(svg$.PathSeg, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, svg$.PathSeg]),
[dartx.appendItem]: dart.definiteFunctionType(svg$.PathSeg, [svg$.PathSeg]),
@@ -88880,8 +89677,8 @@
dart.registerExtension(dart.global.SVGStopElement, svg$.StopElement);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -88906,11 +89703,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -88939,7 +89736,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -88978,8 +89775,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.String, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
[dartx.elementAt]: dart.definiteFunctionType(core.String, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
[dartx.appendItem]: dart.definiteFunctionType(core.String, [core.String]),
@@ -89054,7 +89851,7 @@
this[_element$0] = element;
}
readClasses() {
- let classname = this[_element$0][dartx.attributes][dartx.get]('class');
+ let classname = this[_element$0][dartx.attributes][dartx._get]('class');
let s = LinkedHashSetOfString().new();
if (classname == null) {
return s;
@@ -89068,7 +89865,7 @@
return s;
}
writeClasses(s) {
- this[_element$0][dartx.attributes][dartx.set]('class', s.join(' '));
+ this[_element$0][dartx.attributes][dartx._set]('class', s.join(' '));
}
};
dart.setSignature(svg$._AttributeClassSet, {
@@ -89123,7 +89920,7 @@
svg$.SvgSvgElement = class SvgSvgElement extends svg$.GraphicsElement {
static new() {
let el = svg$.SvgElement.tag("svg");
- el[dartx.attributes][dartx.set]('version', "1.1");
+ el[dartx.attributes][dartx._set]('version', "1.1");
return svg$.SvgSvgElement._check(el);
}
static _() {
@@ -89548,7 +90345,28 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get requiredExtensions() {
+ return this[requiredExtensions];
+ }
+ set requiredExtensions(value) {
+ super.requiredExtensions = value;
+ }
+ get requiredFeatures() {
+ return this[requiredFeatures];
+ }
+ set requiredFeatures(value) {
+ super.requiredFeatures = value;
+ }
+ get systemLanguage() {
+ return this[systemLanguage];
+ }
+ set systemLanguage(value) {
+ super.systemLanguage = value;
+ }
};
+ const requiredExtensions = Symbol(svg$.Tests.name + "." + 'requiredExtensions'.toString());
+ const requiredFeatures = Symbol(svg$.Tests.name + "." + 'requiredFeatures'.toString());
+ const systemLanguage = Symbol(svg$.Tests.name + "." + 'systemLanguage'.toString());
dart.setSignature(svg$.Tests, {
constructors: () => ({_: dart.definiteFunctionType(svg$.Tests, [])}),
fields: () => ({
@@ -89735,8 +90553,8 @@
dart.registerExtension(dart.global.SVGTransform, svg$.Transform);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -89763,11 +90581,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -89796,7 +90614,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -89841,8 +90659,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg$.Transform, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Transform]),
+ [dartx._get]: dart.definiteFunctionType(svg$.Transform, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Transform]),
[dartx.elementAt]: dart.definiteFunctionType(svg$.Transform, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, svg$.Transform]),
[dartx.appendItem]: dart.definiteFunctionType(svg$.Transform, [svg$.Transform]),
@@ -89880,7 +90698,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get href() {
+ return this[href$0];
+ }
+ set href(value) {
+ super.href = value;
+ }
};
+ const href$0 = Symbol(svg$.UriReference.name + "." + 'href'.toString());
dart.setSignature(svg$.UriReference, {
constructors: () => ({_: dart.definiteFunctionType(svg$.UriReference, [])}),
fields: () => ({href: svg$.AnimatedString})
@@ -90062,7 +90887,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get zoomAndPan() {
+ return this[zoomAndPan];
+ }
+ set zoomAndPan(value) {
+ this[zoomAndPan] = value;
+ }
};
+ const zoomAndPan = Symbol(svg$.ZoomAndPan.name + "." + 'zoomAndPan'.toString());
dart.setSignature(svg$.ZoomAndPan, {
constructors: () => ({_: dart.definiteFunctionType(svg$.ZoomAndPan, [])}),
fields: () => ({zoomAndPan: core.int}),
@@ -93805,8 +94637,8 @@
const _item_1 = Symbol('_item_1');
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -93821,11 +94653,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.item](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -93854,7 +94686,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return html_common.convertNativeToDart_Dictionary(this[_item_1](index));
@@ -93874,8 +94706,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.Map, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, core.Map]),
+ [dartx._get]: dart.definiteFunctionType(core.Map, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, core.Map]),
[dartx.elementAt]: dart.definiteFunctionType(core.Map, [core.int]),
[dartx.item]: dart.definiteFunctionType(core.Map, [core.int]),
[_item_1]: dart.definiteFunctionType(dart.dynamic, [dart.dynamic])
diff --git a/pkg/dev_compiler/lib/js/common/dart_sdk.js b/pkg/dev_compiler/lib/js/common/dart_sdk.js
index f10c72e..701109d 100644
--- a/pkg/dev_compiler/lib/js/common/dart_sdk.js
+++ b/pkg/dev_compiler/lib/js/common/dart_sdk.js
@@ -1036,7 +1036,6 @@
let proto = type.prototype;
for (let name of methodNames) {
let method = dart.getOwnPropertyDescriptor(proto, name);
- if (!method) continue;
dart.defineProperty(proto, dart.getExtensionSymbol(name), method);
}
let originalSigFn = dart.getOwnPropertyDescriptor(type, dart._methodSig).get;
@@ -1603,9 +1602,9 @@
dart.getDynamicStats = function() {
let ret = JSArrayOfListOfObject().of([]);
let keys = dart._callMethodStats[dartx.keys][dartx.toList]();
- keys[dartx.sort](dart.fn((a, b) => dart._callMethodStats[dartx.get](b).count[dartx.compareTo](dart._callMethodStats[dartx.get](a).count), StringAndStringToint()));
+ keys[dartx.sort](dart.fn((a, b) => dart._callMethodStats[dartx._get](b).count[dartx.compareTo](dart._callMethodStats[dartx._get](a).count), StringAndStringToint()));
for (let key of keys) {
- let stats = dart._callMethodStats[dartx.get](key);
+ let stats = dart._callMethodStats[dartx._get](key);
ret[dartx.add](JSArrayOfObject().of([stats.typeName, stats.frame, stats.count]));
}
return ret;
@@ -1620,7 +1619,7 @@
let stack = stackStr[dartx.split]('\n at ');
let src = '';
for (let i = 2; i < dart.notNull(stack[dartx.length]); ++i) {
- let frame = stack[dartx.get](i);
+ let frame = stack[dartx._get](i);
if (!dart.test(frame[dartx.contains]('dart_sdk.js'))) {
src = frame;
break;
@@ -1646,10 +1645,10 @@
return dart._callMethod(obj, method, typeArgs, args, method);
};
dart.dindex = function(obj, index) {
- return dart._callMethod(obj, 'get', null, [index], '[]');
+ return dart._callMethod(obj, '_get', null, [index], '[]');
};
dart.dsetindex = function(obj, index, value) {
- return dart._callMethod(obj, 'set', null, [index, value], '[]=');
+ return dart._callMethod(obj, '_set', null, [index, value], '[]=');
};
dart._ignoreMemo = function(f) {
let memo = new Map();
@@ -1772,11 +1771,11 @@
for (let i = 0, end = values.length - 1; i < end; i += 2) {
let key = values[i];
let value = values[i + 1];
- map.set(key, value);
+ map._set(key, value);
}
} else if (typeof values === 'object') {
for (let key of dart.getOwnPropertyNames(values)) {
- map.set(key, values[key]);
+ map._set(key, values[key]);
}
}
return map;
@@ -3116,7 +3115,7 @@
if (genericTypeConstructor != null) {
this.recordGenericParameters(core.String._check(name), genericTypeConstructor);
} else {
- nonGenericProperties.set(core.String._check(name), value);
+ nonGenericProperties._set(core.String._check(name), value);
}
}, dynamicAnddynamicTodynamic$()));
nonGenericProperties.forEach(dart.fn((name, value) => {
@@ -3129,13 +3128,13 @@
return children.toList();
}
recordGenericParameters(name, genericTypeConstructor) {
- this.genericParameters.set(name, genericTypeConstructor.toString()[dartx.split](' =>')[dartx.first][dartx.replaceAll](core.RegExp.new('[(|)]'), ''));
+ this.genericParameters._set(name, genericTypeConstructor.toString()[dartx.split](' =>')[dartx.first][dartx.replaceAll](core.RegExp.new('[(|)]'), ''));
}
classChild(name, child) {
let typeName = _debugger.getTypeName(core.Type._check(child));
let parameterName = dart.str`${name}\$`;
if (dart.test(this.genericParameters.keys[dartx.contains](parameterName))) {
- typeName = dart.str`${typeName}<${this.genericParameters.get(parameterName)}>`;
+ typeName = dart.str`${typeName}<${this.genericParameters._get(parameterName)}>`;
_debugger.JSNative.setProperty(child, 'genericTypeName', typeName);
}
return new _debugger.NameValuePair({name: typeName, value: child});
@@ -3725,8 +3724,8 @@
'hashCode',
'length',
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'asMap'
]);
class JSArray extends core.Object {
@@ -3803,7 +3802,7 @@
this[dartx.checkMutable]('setAll');
core.RangeError.checkValueInInterval(index, 0, this[dartx.length], "index");
for (let element of iterable) {
- this[dartx.set]((() => {
+ this[dartx._set]((() => {
let x = index;
index = dart.notNull(x) + 1;
return x;
@@ -3818,7 +3817,7 @@
[dartx.remove](element) {
this[dartx.checkGrowable]('remove');
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
this.splice(i, 1);
return true;
}
@@ -3846,7 +3845,7 @@
if (retained[dartx.length] == end) return;
this[dartx.length] = retained[dartx.length];
for (let i = 0; i < dart.notNull(retained[dartx.length]); i++) {
- this[dartx.set](i, E._check(retained[dartx.get](i)));
+ this[dartx._set](i, E._check(retained[dartx._get](i)));
}
}
[dartx.where](f) {
@@ -3887,7 +3886,7 @@
if (separator === void 0) separator = "";
let list = core.List.new(this[dartx.length]);
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- list[dartx.set](i, dart.str`${this[dartx.get](i)}`);
+ list[dartx._set](i, dart.str`${this[dartx._get](i)}`);
}
return list.join(separator);
}
@@ -3907,7 +3906,7 @@
EAndEToE()._check(combine);
let length = this[dartx.length];
if (length == 0) dart.throw(_internal.IterableElementError.noElement());
- let value = this[dartx.get](0);
+ let value = this[dartx._get](0);
for (let i = 1; i < dart.notNull(length); i++) {
let element = this[i];
value = combine(value, element);
@@ -3974,7 +3973,7 @@
dart.throw(_internal.IterableElementError.noElement());
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.sublist](start, end) {
if (end === void 0) end = null;
@@ -3999,15 +3998,15 @@
return new (SubListIterableOfE())(this, start, end);
}
get [dartx.first]() {
- if (dart.notNull(this[dartx.length]) > 0) return this[dartx.get](0);
+ if (dart.notNull(this[dartx.length]) > 0) return this[dartx._get](0);
dart.throw(_internal.IterableElementError.noElement());
}
get [dartx.last]() {
- if (dart.notNull(this[dartx.length]) > 0) return this[dartx.get](dart.notNull(this[dartx.length]) - 1);
+ if (dart.notNull(this[dartx.length]) > 0) return this[dartx._get](dart.notNull(this[dartx.length]) - 1);
dart.throw(_internal.IterableElementError.noElement());
}
get [dartx.single]() {
- if (this[dartx.length] == 1) return this[dartx.get](0);
+ if (this[dartx.length] == 1) return this[dartx._get](0);
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
dart.throw(_internal.IterableElementError.tooMany());
}
@@ -4039,12 +4038,12 @@
}
if (dart.notNull(otherStart) < dart.notNull(start)) {
for (let i = length - 1; i >= 0; i--) {
- let element = otherList[dartx.get](dart.notNull(otherStart) + i);
+ let element = otherList[dartx._get](dart.notNull(otherStart) + i);
this[dart.notNull(start) + i] = element;
}
} else {
for (let i = 0; i < length; i++) {
- let element = otherList[dartx.get](dart.notNull(otherStart) + i);
+ let element = otherList[dartx._get](dart.notNull(otherStart) + i);
this[dart.notNull(start) + i] = element;
}
}
@@ -4123,9 +4122,9 @@
while (dart.notNull(length) > 1) {
let pos = random.nextInt(length);
length = dart.notNull(length) - 1;
- let tmp = this[dartx.get](length);
- this[dartx.set](length, this[dartx.get](pos));
- this[dartx.set](pos, tmp);
+ let tmp = this[dartx._get](length);
+ this[dartx._set](length, this[dartx._get](pos));
+ this[dartx._set](pos, tmp);
}
}
[dartx.indexOf](element, start) {
@@ -4137,7 +4136,7 @@
start = 0;
}
for (let i = start; dart.notNull(i) < dart.notNull(this[dartx.length]); i = dart.notNull(i) + 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -4156,7 +4155,7 @@
}
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -4164,7 +4163,7 @@
}
[dartx.contains](other) {
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), other)) return true;
+ if (dart.equals(this[dartx._get](i), other)) return true;
}
return false;
}
@@ -4205,12 +4204,12 @@
}
this.length = newLength;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (!(typeof index == 'number')) dart.throw(_js_helper.diagnoseIndexError(this, index));
if (dart.notNull(index) >= dart.notNull(this[dartx.length]) || dart.notNull(index) < 0) dart.throw(_js_helper.diagnoseIndexError(this, index));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
E._check(value);
this[dartx.checkMutable]('indexed set');
if (!(typeof index == 'number')) dart.throw(_js_helper.diagnoseIndexError(this, index));
@@ -4289,8 +4288,8 @@
[dartx.contains]: dart.definiteFunctionType(core.bool, [core.Object]),
[dartx.toList]: dart.definiteFunctionType(core.List$(E), [], {growable: core.bool}),
[dartx.toSet]: dart.definiteFunctionType(core.Set$(E), []),
- [dartx.get]: dart.definiteFunctionType(E, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, E]),
+ [dartx._get]: dart.definiteFunctionType(E, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, E]),
[dartx.asMap]: dart.definiteFunctionType(core.Map$(core.int, E), [])
}),
statics: () => ({
@@ -4365,7 +4364,7 @@
this[_current] = null;
return false;
}
- this[_current] = this[_iterable][dartx.get](this[_index]);
+ this[_current] = this[_iterable][dartx._get](this[_index]);
this[_index] = dart.notNull(this[_index]) + 1;
return true;
}
@@ -4417,7 +4416,7 @@
'toRadixString',
'toString',
'hashCode',
- 'unary-',
+ '_negate',
'+',
'-',
'/',
@@ -4614,7 +4613,7 @@
get [dartx.hashCode]() {
return this & 0x1FFFFFFF;
}
- [dartx['unary-']]() {
+ [dartx._negate]() {
return -this;
}
[dartx['+']](other) {
@@ -4912,7 +4911,7 @@
[dartx.toStringAsExponential]: dart.definiteFunctionType(core.String, [], [core.int]),
[dartx.toStringAsPrecision]: dart.definiteFunctionType(core.String, [core.int]),
[dartx.toRadixString]: dart.definiteFunctionType(core.String, [core.int]),
- [dartx['unary-']]: dart.definiteFunctionType(_interceptors.JSNumber, []),
+ [dartx._negate]: dart.definiteFunctionType(_interceptors.JSNumber, []),
[dartx['+']]: dart.definiteFunctionType(_interceptors.JSNumber, [core.num]),
[dartx['-']]: dart.definiteFunctionType(_interceptors.JSNumber, [core.num]),
[dartx['/']]: dart.definiteFunctionType(core.double, [core.num]),
@@ -4995,7 +4994,7 @@
'hashCode',
'runtimeType',
'length',
- 'get'
+ '_get'
]);
_interceptors.JSString = class JSString extends _interceptors.Interceptor {
new() {
@@ -5378,7 +5377,7 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (!(typeof index == 'number')) dart.throw(_js_helper.diagnoseIndexError(this, index));
if (dart.notNull(index) >= dart.notNull(this[dartx.length]) || dart.notNull(index) < 0) dart.throw(_js_helper.diagnoseIndexError(this, index));
return this[index];
@@ -5422,7 +5421,7 @@
[dartx.lastIndexOf]: dart.definiteFunctionType(core.int, [core.Pattern], [core.int]),
[dartx.contains]: dart.definiteFunctionType(core.bool, [core.Pattern], [core.int]),
[dartx.compareTo]: dart.definiteFunctionType(core.int, [core.String]),
- [dartx.get]: dart.definiteFunctionType(core.String, [core.int])
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.int])
}),
statics: () => ({
_isWhitespace: dart.definiteFunctionType(core.bool, [core.int]),
@@ -5574,12 +5573,12 @@
return new dart.JsIterator(this[dartx.iterator]);
}
elementAt(index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
forEach(action) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- action(this[dartx.get](i));
+ action(this[dartx._get](i));
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5593,21 +5592,21 @@
}
get first() {
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
- return this[dartx.get](0);
+ return this[dartx._get](0);
}
get last() {
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
- return this[dartx.get](dart.notNull(this[dartx.length]) - 1);
+ return this[dartx._get](dart.notNull(this[dartx.length]) - 1);
}
get single() {
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
if (dart.notNull(this[dartx.length]) > 1) dart.throw(_internal.IterableElementError.tooMany());
- return this[dartx.get](0);
+ return this[dartx._get](0);
}
contains(element) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), element)) return true;
+ if (dart.equals(this[dartx._get](i), element)) return true;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5617,7 +5616,7 @@
every(test) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (!dart.test(test(this[dartx.get](i)))) return false;
+ if (!dart.test(test(this[dartx._get](i)))) return false;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5627,7 +5626,7 @@
any(test) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (dart.test(test(this[dartx.get](i)))) return true;
+ if (dart.test(test(this[dartx._get](i)))) return true;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5639,7 +5638,7 @@
VoidToE()._check(orElse);
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- let element = this[dartx.get](i);
+ let element = this[dartx._get](i);
if (dart.test(test(element))) return element;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
@@ -5653,7 +5652,7 @@
VoidToE()._check(orElse);
let length = this[dartx.length];
for (let i = dart.notNull(length) - 1; i >= 0; i--) {
- let element = this[dartx.get](i);
+ let element = this[dartx._get](i);
if (dart.test(test(element))) return element;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
@@ -5667,7 +5666,7 @@
let match = null;
let matchFound = false;
for (let i = 0; i < dart.notNull(length); i++) {
- let element = this[dartx.get](i);
+ let element = this[dartx._get](i);
if (dart.test(test(element))) {
if (matchFound) {
dart.throw(_internal.IterableElementError.tooMany());
@@ -5706,9 +5705,9 @@
EAndEToE()._check(combine);
let length = this[dartx.length];
if (length == 0) dart.throw(_internal.IterableElementError.noElement());
- let value = this[dartx.get](0);
+ let value = this[dartx._get](0);
for (let i = 1; i < dart.notNull(length); i++) {
- value = combine(value, this[dartx.get](i));
+ value = combine(value, this[dartx._get](i));
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5720,7 +5719,7 @@
let value = initialValue;
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- value = combine(value, this[dartx.get](i));
+ value = combine(value, this[dartx._get](i));
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5750,20 +5749,20 @@
result = ListOfE().new(this[dartx.length]);
}
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- result[dartx.set](i, this[dartx.get](i));
+ result[dartx._set](i, this[dartx._get](i));
}
return result;
}
toSet() {
let result = SetOfE().new();
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- result.add(this[dartx.get](i));
+ result.add(this[dartx._get](i));
}
return result;
}
add(element) {
E._check(element);
- this[dartx.set]((() => {
+ this[dartx._set]((() => {
let x = this[dartx.length];
this[dartx.length] = dart.notNull(x) + 1;
return x;
@@ -5775,13 +5774,13 @@
for (let element of iterable) {
dart.assert(this[dartx.length] == i || dart.test(dart.throw(new core.ConcurrentModificationError(this))));
this[dartx.length] = dart.notNull(i) + 1;
- this[dartx.set](i, element);
+ this[dartx._set](i, element);
i = dart.notNull(i) + 1;
}
}
remove(element) {
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
this[dartx.setRange](i, dart.notNull(this[dartx.length]) - 1, this, i + 1);
this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
return true;
@@ -5799,7 +5798,7 @@
let retained = [];
let length = source[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- let element = source[dartx.get](i);
+ let element = source[dartx._get](i);
if (dart.dcall(test, element) == retainMatching) {
retained[dartx.add](element);
}
@@ -5819,7 +5818,7 @@
if (this[dartx.length] == 0) {
dart.throw(_internal.IterableElementError.noElement());
}
- let result = this[dartx.get](dart.notNull(this[dartx.length]) - 1);
+ let result = this[dartx._get](dart.notNull(this[dartx.length]) - 1);
this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
return result;
}
@@ -5838,9 +5837,9 @@
while (dart.notNull(length) > 1) {
let pos = random.nextInt(length);
length = dart.notNull(length) - 1;
- let tmp = this[dartx.get](length);
- this[dartx.set](length, this[dartx.get](pos));
- this[dartx.set](pos, tmp);
+ let tmp = this[dartx._get](length);
+ this[dartx._set](length, this[dartx._get](pos));
+ this[dartx._set](pos, tmp);
}
}
asMap() {
@@ -5855,7 +5854,7 @@
let result = ListOfE().new();
result[dartx.length] = length;
for (let i = 0; i < length; i++) {
- result[dartx.set](i, this[dartx.get](dart.notNull(start) + i));
+ result[dartx._set](i, this[dartx._get](dart.notNull(start) + i));
}
return result;
}
@@ -5874,7 +5873,7 @@
E._check(fill);
core.RangeError.checkValidRange(start, end, this[dartx.length]);
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- this[dartx.set](i, fill);
+ this[dartx._set](i, fill);
}
}
setRange(start, end, iterable, skipCount) {
@@ -5898,11 +5897,11 @@
}
if (dart.notNull(otherStart) < dart.notNull(start)) {
for (let i = length - 1; i >= 0; i--) {
- this[dartx.set](dart.notNull(start) + i, otherList[dartx.get](dart.notNull(otherStart) + i));
+ this[dartx._set](dart.notNull(start) + i, otherList[dartx._get](dart.notNull(otherStart) + i));
}
} else {
for (let i = 0; i < length; i++) {
- this[dartx.set](dart.notNull(start) + i, otherList[dartx.get](dart.notNull(otherStart) + i));
+ this[dartx._set](dart.notNull(start) + i, otherList[dartx._get](dart.notNull(otherStart) + i));
}
}
}
@@ -5941,7 +5940,7 @@
startIndex = 0;
}
for (let i = startIndex; dart.notNull(i) < dart.notNull(this[dartx.length]); i = dart.notNull(i) + 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -5960,7 +5959,7 @@
}
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -5976,10 +5975,10 @@
if (!(typeof index == 'number')) dart.throw(new core.ArgumentError(index));
this[dartx.length] = dart.notNull(this[dartx.length]) + 1;
this[dartx.setRange](dart.notNull(index) + 1, this[dartx.length], this, index);
- this[dartx.set](index, element);
+ this[dartx._set](index, element);
}
removeAt(index) {
- let result = this[dartx.get](index);
+ let result = this[dartx._get](index);
this[dartx.setRange](index, dart.notNull(this[dartx.length]) - 1, this, dart.notNull(index) + 1);
this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
return result;
@@ -6005,7 +6004,7 @@
this[dartx.setRange](index, dart.notNull(index) + dart.notNull(iterable[dartx.length]), iterable);
} else {
for (let element of iterable) {
- this[dartx.set]((() => {
+ this[dartx._set]((() => {
let x = index;
index = dart.notNull(x) + 1;
return x;
@@ -6154,7 +6153,7 @@
let ETobool = () => (ETobool = dart.constFn(dart.functionType(core.bool, [E])))();
let ComparatorOfE = () => (ComparatorOfE = dart.constFn(core.Comparator$(E)))();
class UnmodifiableListMixin extends core.Object {
- set(index, value) {
+ _set(index, value) {
E._check(value);
dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable list"));
return value;
@@ -6231,7 +6230,7 @@
dart.setSignature(UnmodifiableListMixin, {
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
setAll: dart.definiteFunctionType(dart.void, [core.int, IterableOfE()]),
add: dart.definiteFunctionType(dart.void, [E]),
insert: dart.definiteFunctionType(dart.void, [core.int, E]),
@@ -6252,7 +6251,7 @@
})
});
dart.defineExtensionMembers(UnmodifiableListMixin, [
- 'set',
+ '_set',
'setAll',
'add',
'insert',
@@ -6321,7 +6320,7 @@
set length(value) {
super.length = value;
}
- get(i) {
+ _get(i) {
return this[_string][dartx.codeUnitAt](i);
}
static stringOf(u) {
@@ -6333,11 +6332,11 @@
constructors: () => ({new: dart.definiteFunctionType(_internal.CodeUnits, [core.String])}),
fields: () => ({[_string]: core.String}),
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
- methods: () => ({get: dart.definiteFunctionType(core.int, [core.int])}),
+ methods: () => ({_get: dart.definiteFunctionType(core.int, [core.int])}),
statics: () => ({stringOf: dart.definiteFunctionType(core.String, [_internal.CodeUnits])}),
names: ['stringOf']
});
- dart.defineExtensionMembers(_internal.CodeUnits, ['get', 'length']);
+ dart.defineExtensionMembers(_internal.CodeUnits, ['_get', 'length']);
_internal.EfficientLength = class EfficientLength extends core.Object {};
core.Iterable$ = dart.generic(E => {
let EmptyIterableOfE = () => (EmptyIterableOfE = dart.constFn(_internal.EmptyIterable$(E)))();
@@ -6856,7 +6855,7 @@
result = ListOfE().new(this.length);
}
for (let i = 0; i < dart.notNull(this.length); i++) {
- result[dartx.set](i, this.elementAt(i));
+ result[dartx._set](i, this.elementAt(i));
}
return result;
}
@@ -7004,7 +7003,7 @@
return _;
})() : ListOfE().new(length);
for (let i = 0; i < length; i++) {
- result[dartx.set](i, this[_iterable$][dartx.elementAt](dart.notNull(start) + i));
+ result[dartx._set](i, this[_iterable$][dartx.elementAt](dart.notNull(start) + i));
if (dart.notNull(this[_iterable$][dartx.length]) < dart.notNull(end)) dart.throw(new core.ConcurrentModificationError(this));
}
return result;
@@ -8054,8 +8053,8 @@
new(values) {
this[_values] = values;
}
- get(key) {
- return dart.test(this.containsKey(key)) ? this[_values][dartx.get](core.int._check(key)) : null;
+ _get(key) {
+ return dart.test(this.containsKey(key)) ? this[_values][dartx._get](core.int._check(key)) : null;
}
get length() {
return this[_values][dartx.length];
@@ -8081,13 +8080,13 @@
forEach(f) {
let length = this[_values][dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- f(i, this[_values][dartx.get](i));
+ f(i, this[_values][dartx._get](i));
if (length != this[_values][dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this[_values]));
}
}
}
- set(key, value) {
+ _set(key, value) {
E._check(value);
dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable map"));
return value;
@@ -8123,11 +8122,11 @@
isNotEmpty: dart.definiteFunctionType(core.bool, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(E, [core.Object]),
+ _get: dart.definiteFunctionType(E, [core.Object]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
forEach: dart.definiteFunctionType(dart.void, [intAndETovoid()]),
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
putIfAbsent: dart.definiteFunctionType(E, [core.int, VoidToE()]),
remove: dart.definiteFunctionType(E, [core.Object]),
clear: dart.definiteFunctionType(dart.void, []),
@@ -8135,11 +8134,11 @@
})
});
dart.defineExtensionMembers(ListMapView, [
- 'get',
+ '_get',
'containsValue',
'containsKey',
'forEach',
- 'set',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -8236,11 +8235,11 @@
static copy(src, srcStart, dst, dstStart, count) {
if (dart.notNull(srcStart) < dart.notNull(dstStart)) {
for (let i = dart.notNull(srcStart) + dart.notNull(count) - 1, j = dart.notNull(dstStart) + dart.notNull(count) - 1; i >= dart.notNull(srcStart); i--, j--) {
- dst[dartx.set](j, src[dartx.get](i));
+ dst[dartx._set](j, src[dartx._get](i));
}
} else {
for (let i = srcStart, j = dstStart; dart.notNull(i) < dart.notNull(srcStart) + dart.notNull(count); i = dart.notNull(i) + 1, j = dart.notNull(j) + 1) {
- dst[dartx.set](j, src[dartx.get](i));
+ dst[dartx._set](j, src[dartx._get](i));
}
}
}
@@ -8250,7 +8249,7 @@
let length = a[dartx.length];
if (!dart.equals(length, dart.dload(b, 'length'))) return false;
for (let i = 0; i < dart.notNull(length); i++) {
- if (!core.identical(a[dartx.get](i), dart.dindex(b, i))) return false;
+ if (!core.identical(a[dartx._get](i), dart.dindex(b, i))) return false;
}
return true;
}
@@ -8262,7 +8261,7 @@
startIndex = 0;
}
for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dart.notNull(i) + 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -8276,7 +8275,7 @@
startIndex = dart.notNull(a[dartx.length]) - 1;
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -8336,13 +8335,13 @@
static _insertionSort(E) {
return (a, left, right, compare) => {
for (let i = dart.notNull(left) + 1; i <= dart.notNull(right); i++) {
- let el = a[dartx.get](i);
+ let el = a[dartx._get](i);
let j = i;
- while (j > dart.notNull(left) && dart.notNull(compare(a[dartx.get](j - 1), el)) > 0) {
- a[dartx.set](j, a[dartx.get](j - 1));
+ while (j > dart.notNull(left) && dart.notNull(compare(a[dartx._get](j - 1), el)) > 0) {
+ a[dartx._set](j, a[dartx._get](j - 1));
j--;
}
- a[dartx.set](j, el);
+ a[dartx._set](j, el);
}
};
}
@@ -8355,11 +8354,11 @@
let index3 = ((dart.notNull(left) + dart.notNull(right)) / 2)[dartx.truncate]();
let index2 = index3 - sixth;
let index4 = index3 + sixth;
- let el1 = a[dartx.get](index1);
- let el2 = a[dartx.get](index2);
- let el3 = a[dartx.get](index3);
- let el4 = a[dartx.get](index4);
- let el5 = a[dartx.get](index5);
+ let el1 = a[dartx._get](index1);
+ let el2 = a[dartx._get](index2);
+ let el3 = a[dartx._get](index3);
+ let el4 = a[dartx._get](index4);
+ let el5 = a[dartx._get](index5);
if (dart.notNull(compare(el1, el2)) > 0) {
let t = el1;
el1 = el2;
@@ -8407,40 +8406,40 @@
}
let pivot1 = el2;
let pivot2 = el4;
- a[dartx.set](index1, el1);
- a[dartx.set](index3, el3);
- a[dartx.set](index5, el5);
- a[dartx.set](index2, a[dartx.get](left));
- a[dartx.set](index4, a[dartx.get](right));
+ a[dartx._set](index1, el1);
+ a[dartx._set](index3, el3);
+ a[dartx._set](index5, el5);
+ a[dartx._set](index2, a[dartx._get](left));
+ a[dartx._set](index4, a[dartx._get](right));
let less = dart.notNull(left) + 1;
let great = dart.notNull(right) - 1;
let pivots_are_equal = compare(pivot1, pivot2) == 0;
if (pivots_are_equal) {
let pivot = pivot1;
for (let k = less; k <= great; k++) {
- let ak = a[dartx.get](k);
+ let ak = a[dartx._get](k);
let comp = compare(ak, pivot);
if (comp == 0) continue;
if (dart.notNull(comp) < 0) {
if (k != less) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less, ak);
}
less++;
} else {
while (true) {
- comp = compare(a[dartx.get](great), pivot);
+ comp = compare(a[dartx._get](great), pivot);
if (dart.notNull(comp) > 0) {
great--;
continue;
} else if (dart.notNull(comp) < 0) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less++, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less++, a[dartx._get](great));
+ a[dartx._set](great--, ak);
break;
} else {
- a[dartx.set](k, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](great));
+ a[dartx._set](great--, ak);
break;
}
}
@@ -8448,32 +8447,32 @@
}
} else {
for (let k = less; k <= great; k++) {
- let ak = a[dartx.get](k);
+ let ak = a[dartx._get](k);
let comp_pivot1 = compare(ak, pivot1);
if (dart.notNull(comp_pivot1) < 0) {
if (k != less) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less, ak);
}
less++;
} else {
let comp_pivot2 = compare(ak, pivot2);
if (dart.notNull(comp_pivot2) > 0) {
while (true) {
- let comp = compare(a[dartx.get](great), pivot2);
+ let comp = compare(a[dartx._get](great), pivot2);
if (dart.notNull(comp) > 0) {
great--;
if (great < k) break;
continue;
} else {
- comp = compare(a[dartx.get](great), pivot1);
+ comp = compare(a[dartx._get](great), pivot1);
if (dart.notNull(comp) < 0) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less++, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less++, a[dartx._get](great));
+ a[dartx._set](great--, ak);
} else {
- a[dartx.set](k, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](great));
+ a[dartx._set](great--, ak);
}
break;
}
@@ -8482,49 +8481,49 @@
}
}
}
- a[dartx.set](left, a[dartx.get](less - 1));
- a[dartx.set](less - 1, pivot1);
- a[dartx.set](right, a[dartx.get](great + 1));
- a[dartx.set](great + 1, pivot2);
+ a[dartx._set](left, a[dartx._get](less - 1));
+ a[dartx._set](less - 1, pivot1);
+ a[dartx._set](right, a[dartx._get](great + 1));
+ a[dartx._set](great + 1, pivot2);
_internal.Sort._doSort(E)(a, left, less - 2, compare);
_internal.Sort._doSort(E)(a, great + 2, right, compare);
if (pivots_are_equal) {
return;
}
if (less < index1 && great > index5) {
- while (compare(a[dartx.get](less), pivot1) == 0) {
+ while (compare(a[dartx._get](less), pivot1) == 0) {
less++;
}
- while (compare(a[dartx.get](great), pivot2) == 0) {
+ while (compare(a[dartx._get](great), pivot2) == 0) {
great--;
}
for (let k = less; k <= great; k++) {
- let ak = a[dartx.get](k);
+ let ak = a[dartx._get](k);
let comp_pivot1 = compare(ak, pivot1);
if (comp_pivot1 == 0) {
if (k != less) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less, ak);
}
less++;
} else {
let comp_pivot2 = compare(ak, pivot2);
if (comp_pivot2 == 0) {
while (true) {
- let comp = compare(a[dartx.get](great), pivot2);
+ let comp = compare(a[dartx._get](great), pivot2);
if (comp == 0) {
great--;
if (great < k) break;
continue;
} else {
- comp = compare(a[dartx.get](great), pivot1);
+ comp = compare(a[dartx._get](great), pivot1);
if (dart.notNull(comp) < 0) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less++, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less++, a[dartx._get](great));
+ a[dartx._set](great--, ak);
} else {
- a[dartx.set](k, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](great));
+ a[dartx._set](great--, ak);
}
break;
}
@@ -8899,8 +8898,8 @@
return;
}
let message = core.List.new(2);
- message[dartx.set](0, dart.toString(error));
- message[dartx.set](1, stackTrace == null ? null : dart.toString(stackTrace));
+ message[dartx._set](0, dart.toString(error));
+ message[dartx._set](1, stackTrace == null ? null : dart.toString(stackTrace));
for (let port of this.errorPorts)
port.send(message);
}
@@ -8988,13 +8987,13 @@
}
}
lookup(portId) {
- return this.ports[dartx.get](portId);
+ return this.ports[dartx._get](portId);
}
[_addRegistration](portId, port) {
if (dart.test(this.ports[dartx.containsKey](portId))) {
dart.throw(core.Exception.new("Registry: ports must be registered only once."));
}
- this.ports[dartx.set](portId, port);
+ this.ports[dartx._set](portId, port);
}
register(portId, port) {
this[_addRegistration](portId, port);
@@ -9006,7 +9005,7 @@
}
[_updateGlobalState]() {
if (dart.notNull(this.ports[dartx.length]) - dart.notNull(this.weakPorts.length) > 0 || dart.test(this.isPaused) || !dart.test(this.initialized)) {
- _isolate_helper._globalState.isolates[dartx.set](this.id, this);
+ _isolate_helper._globalState.isolates[dartx._set](this.id, this);
} else {
this.kill();
}
@@ -9291,7 +9290,7 @@
}
case 'close':
{
- _isolate_helper._globalState.managers[dartx.remove](_isolate_helper.IsolateNatives.workerIds.get(sender));
+ _isolate_helper._globalState.managers[dartx.remove](_isolate_helper.IsolateNatives.workerIds._get(sender));
sender.terminate();
_isolate_helper._globalState.topEventLoop.run();
break;
@@ -9454,8 +9453,8 @@
let o = _isolate_helper._globalState;
let workerId = o.nextManagerId;
o.nextManagerId = dart.notNull(workerId) + 1;
- _isolate_helper.IsolateNatives.workerIds.set(worker, workerId);
- _isolate_helper._globalState.managers[dartx.set](workerId, worker);
+ _isolate_helper.IsolateNatives.workerIds._set(worker, workerId);
+ _isolate_helper._globalState.managers[dartx._set](workerId, worker);
worker.postMessage(_isolate_helper._serializeMessage(dart.map({command: 'start', id: workerId, replyTo: _isolate_helper._serializeMessage(replyPort), args: args, msg: _isolate_helper._serializeMessage(message), isSpawnUri: isSpawnUri, startPaused: startPaused, functionName: functionName}, core.String, core.Object)));
}
static workerOnError(event, uri, onError) {
@@ -9538,7 +9537,7 @@
super.new(isolateId);
}
send(message) {
- let isolate = _isolate_helper._globalState.isolates[dartx.get](this[_isolateId]);
+ let isolate = _isolate_helper._globalState.isolates[dartx._get](this[_isolateId]);
if (isolate == null) return;
if (dart.test(this[_receivePort][_isClosed])) return;
let msg = _isolate_helper._clone(message);
@@ -9578,7 +9577,7 @@
if (dart.test(_isolate_helper._globalState.isWorker)) {
_isolate_helper._globalState.mainManager.postMessage(workerMessage);
} else {
- let manager = _isolate_helper._globalState.managers[dartx.get](this[_workerId]);
+ let manager = _isolate_helper._globalState.managers[dartx._get](this[_workerId]);
if (manager != null) {
manager.postMessage(workerMessage);
}
@@ -10616,10 +10615,10 @@
}
serialize(x) {
if (dart.test(this.isPrimitive(x))) return this.serializePrimitive(x);
- let serializationId = this.serializedObjectIds[dartx.get](x);
+ let serializationId = this.serializedObjectIds[dartx._get](x);
if (serializationId != null) return this.makeRef(serializationId);
serializationId = this.serializedObjectIds[dartx.length];
- this.serializedObjectIds[dartx.set](x, serializationId);
+ this.serializedObjectIds[dartx._set](x, serializationId);
if (_native_typed_data.NativeByteBuffer.is(x)) return this.serializeByteBuffer(x);
if (_native_typed_data.NativeTypedData.is(x)) return this.serializeTypedData(x);
if (_interceptors.JSIndexable.is(x)) return this.serializeJSIndexable(x);
@@ -10668,13 +10667,13 @@
let serialized = [];
serialized[dartx.length] = x[dartx.length];
for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
- serialized[dartx.set](i, this.serialize(x[dartx.get](i)));
+ serialized[dartx._set](i, this.serialize(x[dartx._get](i)));
}
return serialized;
}
serializeArrayInPlace(x) {
for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
- x[dartx.set](i, this.serialize(x[dartx.get](i)));
+ x[dartx._set](i, this.serialize(x[dartx._get](i)));
}
return x;
}
@@ -10690,7 +10689,7 @@
let values = [];
values[dartx.length] = keys[dartx.length];
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- values[dartx.set](i, this.serialize(x[keys[dartx.get](i)]));
+ values[dartx._set](i, this.serialize(x[keys[dartx._get](i)]));
}
return JSArrayOfObject().of(['js-object', keys, values]);
}
@@ -10829,7 +10828,7 @@
deserializeRef(x) {
dart.assert(dart.equals(dart.dindex(x, 0), 'ref'));
let serializationId = core.int._check(dart.dindex(x, 1));
- return this.deserializedObjects[dartx.get](serializationId);
+ return this.deserializedObjects[dartx._get](serializationId);
}
deserializeByteBuffer(x) {
dart.assert(dart.equals(dart.dindex(x, 0), 'buffer'));
@@ -10845,7 +10844,7 @@
}
deserializeArrayInPlace(x) {
for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
- x[dartx.set](i, this.deserialize(x[dartx.get](i)));
+ x[dartx._set](i, this.deserialize(x[dartx._get](i)));
}
return x;
}
@@ -10874,14 +10873,14 @@
return _interceptors.JSArray.markFixed(this.deserializeArrayInPlace(_interceptors.JSArray._check(result)));
}
deserializeMap(x) {
- dart.assert(dart.equals(x.get(0), 'map'));
- let keys = core.List._check(x.get(1));
- let values = core.List._check(x.get(2));
+ dart.assert(dart.equals(x._get(0), 'map'));
+ let keys = core.List._check(x._get(1));
+ let values = core.List._check(x._get(2));
let result = dart.map();
this.deserializedObjects[dartx.add](result);
keys = keys[dartx.map](dart.dynamic)(dart.bind(this, 'deserialize'))[dartx.toList]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- result[dartx.set](keys[dartx.get](i), this.deserialize(values[dartx.get](i)));
+ result[dartx._set](keys[dartx._get](i), this.deserialize(values[dartx._get](i)));
}
return result;
}
@@ -10892,7 +10891,7 @@
let receivePortId = core.int._check(dart.dindex(x, 3));
let result = null;
if (managerId == _isolate_helper._globalState.currentManagerId) {
- let isolate = _isolate_helper._globalState.isolates[dartx.get](isolateId);
+ let isolate = _isolate_helper._globalState.isolates[dartx._get](isolateId);
if (isolate == null) return null;
let receivePort = isolate.lookup(receivePortId);
if (receivePort == null) return null;
@@ -10916,7 +10915,7 @@
let o = {};
this.deserializedObjects[dartx.add](o);
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- o[keys[dartx.get](i)] = this.deserialize(values[dartx.get](i));
+ o[keys[dartx._get](i)] = this.deserialize(values[dartx._get](i));
}
return o;
}
@@ -11040,12 +11039,12 @@
if (match == null) {
return _js_helper.Primitives._parseIntError(source, handleError);
}
- let decimalMatch = match[dartx.get](decimalIndex);
+ let decimalMatch = match[dartx._get](decimalIndex);
if (radix == null) {
if (decimalMatch != null) {
return parseInt(source, 10);
}
- if (match[dartx.get](hexIndex) != null) {
+ if (match[dartx._get](hexIndex) != null) {
return parseInt(source, 16);
}
return _js_helper.Primitives._parseIntError(source, handleError);
@@ -11066,7 +11065,7 @@
} else {
maxCharCode = 97 - 10 - 1 + dart.notNull(radix);
}
- dart.assert(typeof match[dartx.get](digitsIndex) == 'string');
+ dart.assert(typeof match[dartx._get](digitsIndex) == 'string');
let digitsPart = match[digitsIndex];
for (let i = 0; i < dart.notNull(digitsPart[dartx.length]); i++) {
let characterCode = (dart.notNull(digitsPart[dartx.codeUnitAt](i)) | 32) >>> 0;
@@ -11204,11 +11203,11 @@
static getTimeZoneName(receiver) {
let d = _js_helper.Primitives.lazyAsJsDate(receiver);
let match = /\((.*)\)/.exec(d.toString());
- if (match != null) return core.String._check(match[dartx.get](1));
+ if (match != null) return core.String._check(match[dartx._get](1));
match = /^[A-Z,a-z]{3}\s[A-Z,a-z]{3}\s\d+\s\d{2}:\d{2}:\d{2}\s([A-Z]{3,5})\s\d{4}$/.exec(d.toString());
- if (match != null) return core.String._check(match[dartx.get](1));
+ if (match != null) return core.String._check(match[dartx._get](1));
match = /(?:GMT|UTC)[+-]\d{4}/.exec(d.toString());
- if (match != null) return core.String._check(match[dartx.get](0));
+ if (match != null) return core.String._check(match[dartx._get](0));
return "";
}
static getTimeZoneOffsetInMinutes(receiver) {
@@ -11560,7 +11559,7 @@
while (index < dart.notNull(length)) {
let key = _js_helper.getIndex(keyValuePairs, index++);
let value = _js_helper.getIndex(keyValuePairs, index++);
- result[dartx.set](key, value);
+ result[dartx._set](key, value);
}
return result;
};
@@ -11964,7 +11963,7 @@
return new (LinkedHashMapKeyIterableOfK())(this);
}
get values() {
- return MappedIterableOfK$V().new(this.keys, dart.fn(each => this.get(each), KToV()));
+ return MappedIterableOfK$V().new(this.keys, dart.fn(each => this._get(each), KToV()));
}
containsKey(key) {
if (dart.test(_js_helper.JsLinkedHashMap._isStringKey(key))) {
@@ -11986,15 +11985,15 @@
return dart.notNull(this.internalFindBucketIndex(bucket, key)) >= 0;
}
containsValue(value) {
- return this.keys[dartx.any](dart.fn(each => dart.equals(this.get(each), value), KTobool()));
+ return this.keys[dartx.any](dart.fn(each => dart.equals(this._get(each), value), KTobool()));
}
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
- get(key) {
+ _get(key) {
if (dart.test(_js_helper.JsLinkedHashMap._isStringKey(key))) {
let strings = this[_strings];
if (strings == null) return null;
@@ -12018,7 +12017,7 @@
let cell = bucket[index];
return cell.hashMapCellValue;
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
if (dart.test(_js_helper.JsLinkedHashMap._isStringKey(key))) {
@@ -12058,9 +12057,9 @@
putIfAbsent(key, ifAbsent) {
K._check(key);
VoidToV()._check(ifAbsent);
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
@@ -12233,9 +12232,9 @@
internalContainsKey: dart.definiteFunctionType(core.bool, [core.Object]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
- get: dart.definiteFunctionType(V, [core.Object]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
internalGet: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
internalSet: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
remove: dart.definiteFunctionType(V, [core.Object]),
@@ -12267,8 +12266,8 @@
'containsKey',
'containsValue',
'addAll',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -12555,7 +12554,7 @@
regexp.lastIndex = start;
let match = regexp.exec(string);
if (match == null) return null;
- if (match[dartx.get](dart.notNull(match[dartx.length]) - 1) != null) return null;
+ if (match[dartx._get](dart.notNull(match[dartx.length]) - 1) != null) return null;
match[dartx.length] = dart.notNull(match[dartx.length]) - 1;
return new _js_helper._MatchImplementation(this, ListOfString()._check(match));
}
@@ -12618,12 +12617,12 @@
return this[_match].index;
}
get end() {
- return dart.notNull(this.start) + dart.notNull(this[_match][dartx.get](0)[dartx.length]);
+ return dart.notNull(this.start) + dart.notNull(this[_match][dartx._get](0)[dartx.length]);
}
group(index) {
- return this[_match][dartx.get](index);
+ return this[_match][dartx._get](index);
}
- get(index) {
+ _get(index) {
return this.group(index);
}
get groupCount() {
@@ -12652,7 +12651,7 @@
}),
methods: () => ({
group: dart.definiteFunctionType(core.String, [core.int]),
- get: dart.definiteFunctionType(core.String, [core.int]),
+ _get: dart.definiteFunctionType(core.String, [core.int]),
groups: dart.definiteFunctionType(core.List$(core.String), [ListOfint()])
})
});
@@ -12754,7 +12753,7 @@
get end() {
return dart.notNull(this.start) + dart.notNull(this.pattern[dartx.length]);
}
- get(g) {
+ _get(g) {
return this.group(g);
}
get groupCount() {
@@ -12787,7 +12786,7 @@
groupCount: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(core.String, [core.int]),
+ _get: dart.definiteFunctionType(core.String, [core.int]),
group: dart.definiteFunctionType(core.String, [core.int]),
groups: dart.definiteFunctionType(core.List$(core.String), [ListOfint()])
})
@@ -12910,7 +12909,7 @@
let length = receiver[dartx.length];
result.write(replacement);
for (let i = 0; i < dart.notNull(length); i++) {
- result.write(receiver[dartx.get](i));
+ result.write(receiver[dartx._get](i));
result.write(replacement);
}
return result.toString();
@@ -12930,7 +12929,7 @@
};
dart.lazyFn(_js_helper.stringReplaceAllUnchecked, () => StringAndPatternAndStringToString());
_js_helper._matchString = function(match) {
- return match.get(0);
+ return match._get(0);
};
dart.lazyFn(_js_helper._matchString, () => MatchToString$());
_js_helper._stringIdentity = function(string) {
@@ -12973,7 +12972,7 @@
continue;
}
}
- buffer.write(onNonMatch(receiver[dartx.get](i)));
+ buffer.write(onNonMatch(receiver[dartx._get](i)));
i++;
}
buffer.write(onMatch(new _js_helper.StringMatch(i, receiver, "")));
@@ -13142,7 +13141,7 @@
let privateMembers = Object.getOwnPropertySymbols(data);
for (let member of core.Iterable._check(privateMembers)) {
let name = _js_mirrors._getNameForESSymbol(member);
- map[dartx.set](name, data[member]);
+ map[dartx._set](name, data[member]);
}
return map;
};
@@ -13429,13 +13428,13 @@
let constructors = _js_mirrors._getConstructors(unwrapped);
constructors[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
}, StringAnddynamicTovoid()));
if (dart.test(constructors[dartx.isEmpty])) {
let name = 'new';
let ft = _js_mirrors._defaultConstructorType(_js_mirrors._unwrap(this[_cls]));
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
}
let fields = _js_mirrors._getFields(unwrapped);
fields[dartx.forEach](dart.fn((name, t) => {
@@ -13445,23 +13444,23 @@
metadata = core.List._check(dart.dsend(dart.dsend(t, 'skip', 1), 'toList'));
t = dart.dindex(t, 0);
}
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
}, StringAnddynamicTovoid()));
let methods = _js_mirrors._getMethods(unwrapped);
methods[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let getters = _js_mirrors._getGetters(unwrapped);
getters[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let setters = _js_mirrors._getSetters(unwrapped);
setters[dartx.forEach](dart.fn((name, ft) => {
name = dart.notNull(name) + '=';
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let staticFields = _js_mirrors._getStaticFields(unwrapped);
staticFields[dartx.forEach](dart.fn((name, t) => {
@@ -13471,22 +13470,22 @@
metadata = core.List._check(dart.dsend(dart.dsend(t, 'skip', 1), 'toList'));
t = dart.dindex(t, 0);
}
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
}, StringAnddynamicTovoid()));
let statics = _js_mirrors._getStatics(unwrapped);
statics[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let staticGetters = _js_mirrors._getStaticGetters(unwrapped);
staticGetters[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let staticSetters = _js_mirrors._getStaticSetters(unwrapped);
staticSetters[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
}, StringAnddynamicTovoid()));
this[_declarations] = MapOfSymbol$DeclarationMirror().unmodifiable(this[_declarations]);
}
@@ -13798,16 +13797,16 @@
let opts = core.List._check(dart.dload(ftype, 'optionals'));
let params = ListOfParameterMirror().new(dart.notNull(args[dartx.length]) + dart.notNull(opts[dartx.length]));
for (let i = 0; i < dart.notNull(args[dartx.length]); ++i) {
- let type = args[dartx.get](i);
+ let type = args[dartx._get](i);
let metadata = dart.dindex(dart.dload(ftype, 'metadata'), i);
let param = new _js_mirrors.JsParameterMirror._('', core.Type._check(_js_mirrors._wrap(type)), core.List._check(metadata));
- params[dartx.set](i, param);
+ params[dartx._set](i, param);
}
for (let i = 0; i < dart.notNull(opts[dartx.length]); ++i) {
- let type = opts[dartx.get](i);
+ let type = opts[dartx._get](i);
let metadata = dart.dindex(dart.dload(ftype, 'metadata'), dart.notNull(args[dartx.length]) + i);
let param = new _js_mirrors.JsParameterMirror._('', core.Type._check(_js_mirrors._wrap(type)), core.List._check(metadata));
- params[dartx.set](i + dart.notNull(args[dartx.length]), param);
+ params[dartx._set](i + dart.notNull(args[dartx.length]), param);
}
this[_params] = ListOfParameterMirror().unmodifiable(params);
}
@@ -14641,11 +14640,11 @@
_slowFromList(list) {
this[_storage] = _native_typed_data.NativeFloat32List.new(dart.notNull(list[dartx.length]) * 4);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- let e = list[dartx.get](i);
- this[_storage][dartx.set](i * 4 + 0, e.x);
- this[_storage][dartx.set](i * 4 + 1, e.y);
- this[_storage][dartx.set](i * 4 + 2, e.z);
- this[_storage][dartx.set](i * 4 + 3, e.w);
+ let e = list[dartx._get](i);
+ this[_storage][dartx._set](i * 4 + 0, e.x);
+ this[_storage][dartx._set](i * 4 + 1, e.y);
+ this[_storage][dartx._set](i * 4 + 2, e.z);
+ this[_storage][dartx._set](i * 4 + 3, e.w);
}
}
get runtimeType() {
@@ -14676,20 +14675,20 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this.length);
- let _x = this[_storage][dartx.get](dart.notNull(index) * 4 + 0);
- let _y = this[_storage][dartx.get](dart.notNull(index) * 4 + 1);
- let _z = this[_storage][dartx.get](dart.notNull(index) * 4 + 2);
- let _w = this[_storage][dartx.get](dart.notNull(index) * 4 + 3);
+ let _x = this[_storage][dartx._get](dart.notNull(index) * 4 + 0);
+ let _y = this[_storage][dartx._get](dart.notNull(index) * 4 + 1);
+ let _z = this[_storage][dartx._get](dart.notNull(index) * 4 + 2);
+ let _w = this[_storage][dartx._get](dart.notNull(index) * 4 + 3);
return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this.length);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 0, value.x);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 1, value.y);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 2, value.z);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 3, value.w);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 0, value.x);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 1, value.y);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 2, value.z);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 3, value.w);
return value;
}
sublist(start, end) {
@@ -14717,14 +14716,14 @@
length: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(typed_data.Float32x4, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float32x4]),
+ _get: dart.definiteFunctionType(typed_data.Float32x4, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float32x4]),
sublist: dart.definiteFunctionType(core.List$(typed_data.Float32x4), [core.int], [core.int])
})
});
dart.defineExtensionMembers(_native_typed_data.NativeFloat32x4List, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sublist',
'buffer',
'lengthInBytes',
@@ -15274,11 +15273,11 @@
_slowFromList(list) {
this[_storage] = _native_typed_data.NativeInt32List.new(dart.notNull(list[dartx.length]) * 4);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- let e = list[dartx.get](i);
- this[_storage][dartx.set](i * 4 + 0, e.x);
- this[_storage][dartx.set](i * 4 + 1, e.y);
- this[_storage][dartx.set](i * 4 + 2, e.z);
- this[_storage][dartx.set](i * 4 + 3, e.w);
+ let e = list[dartx._get](i);
+ this[_storage][dartx._set](i * 4 + 0, e.x);
+ this[_storage][dartx._set](i * 4 + 1, e.y);
+ this[_storage][dartx._set](i * 4 + 2, e.z);
+ this[_storage][dartx._set](i * 4 + 3, e.w);
}
}
get runtimeType() {
@@ -15309,20 +15308,20 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this.length);
- let _x = this[_storage][dartx.get](dart.notNull(index) * 4 + 0);
- let _y = this[_storage][dartx.get](dart.notNull(index) * 4 + 1);
- let _z = this[_storage][dartx.get](dart.notNull(index) * 4 + 2);
- let _w = this[_storage][dartx.get](dart.notNull(index) * 4 + 3);
+ let _x = this[_storage][dartx._get](dart.notNull(index) * 4 + 0);
+ let _y = this[_storage][dartx._get](dart.notNull(index) * 4 + 1);
+ let _z = this[_storage][dartx._get](dart.notNull(index) * 4 + 2);
+ let _w = this[_storage][dartx._get](dart.notNull(index) * 4 + 3);
return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this.length);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 0, value.x);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 1, value.y);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 2, value.z);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 3, value.w);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 0, value.x);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 1, value.y);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 2, value.z);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 3, value.w);
return value;
}
sublist(start, end) {
@@ -15350,14 +15349,14 @@
length: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Int32x4]),
+ _get: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Int32x4]),
sublist: dart.definiteFunctionType(core.List$(typed_data.Int32x4), [core.int], [core.int])
})
});
dart.defineExtensionMembers(_native_typed_data.NativeInt32x4List, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sublist',
'buffer',
'lengthInBytes',
@@ -15397,9 +15396,9 @@
_slowFromList(list) {
this[_storage] = _native_typed_data.NativeFloat64List.new(dart.notNull(list[dartx.length]) * 2);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- let e = list[dartx.get](i);
- this[_storage][dartx.set](i * 2 + 0, e.x);
- this[_storage][dartx.set](i * 2 + 1, e.y);
+ let e = list[dartx._get](i);
+ this[_storage][dartx._set](i * 2 + 0, e.x);
+ this[_storage][dartx._set](i * 2 + 1, e.y);
}
}
static fromList(list) {
@@ -15430,16 +15429,16 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this.length);
- let _x = this[_storage][dartx.get](dart.notNull(index) * 2 + 0);
- let _y = this[_storage][dartx.get](dart.notNull(index) * 2 + 1);
+ let _x = this[_storage][dartx._get](dart.notNull(index) * 2 + 0);
+ let _y = this[_storage][dartx._get](dart.notNull(index) * 2 + 1);
return typed_data.Float64x2.new(_x, _y);
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this.length);
- this[_storage][dartx.set](dart.notNull(index) * 2 + 0, value.x);
- this[_storage][dartx.set](dart.notNull(index) * 2 + 1, value.y);
+ this[_storage][dartx._set](dart.notNull(index) * 2 + 0, value.x);
+ this[_storage][dartx._set](dart.notNull(index) * 2 + 1, value.y);
return value;
}
sublist(start, end) {
@@ -15467,14 +15466,14 @@
length: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(typed_data.Float64x2, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float64x2]),
+ _get: dart.definiteFunctionType(typed_data.Float64x2, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float64x2]),
sublist: dart.definiteFunctionType(core.List$(typed_data.Float64x2), [core.int], [core.int])
})
});
dart.defineExtensionMembers(_native_typed_data.NativeFloat64x2List, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sublist',
'buffer',
'lengthInBytes',
@@ -15551,7 +15550,7 @@
if (_interceptors.JSIndexable.is(list)) return list;
let result = core.List.new(list[dartx.length]);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- result[dartx.set](i, list[dartx.get](i));
+ result[dartx._set](i, list[dartx._get](i));
}
return result;
};
@@ -15801,8 +15800,8 @@
});
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'setRange'
]);
_native_typed_data.NativeTypedArrayOfDouble = class NativeTypedArrayOfDouble extends dart.mixin(_native_typed_data.NativeTypedArray, collection.ListMixin$(core.double), _internal.FixedLengthListMixin$(core.double)) {
@@ -15812,11 +15811,11 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
this[index] = value;
return value;
@@ -15833,15 +15832,15 @@
dart.setSignature(_native_typed_data.NativeTypedArrayOfDouble, {
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
- get: dart.definiteFunctionType(core.double, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, core.num]),
+ _get: dart.definiteFunctionType(core.double, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, core.num]),
setRange: dart.definiteFunctionType(dart.void, [core.int, core.int, IterableOfdouble()], [core.int])
})
});
- dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfDouble, ['get', 'set', 'setRange', 'length']);
+ dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfDouble, ['_get', '_set', 'setRange', 'length']);
dart.defineExtensionNames([
'length',
- 'set',
+ '_set',
'setRange'
]);
_native_typed_data.NativeTypedArrayOfInt = class NativeTypedArrayOfInt extends dart.mixin(_native_typed_data.NativeTypedArray, collection.ListMixin$(core.int), _internal.FixedLengthListMixin$(core.int)) {
@@ -15851,7 +15850,7 @@
set length(value) {
super.length = value;
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
this[index] = value;
return value;
@@ -15869,11 +15868,11 @@
dart.setSignature(_native_typed_data.NativeTypedArrayOfInt, {
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
- set: dart.definiteFunctionType(dart.void, [core.int, core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, core.int]),
setRange: dart.definiteFunctionType(dart.void, [core.int, core.int, IterableOfint()], [core.int])
})
});
- dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfInt, ['set', 'setRange', 'length']);
+ dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfInt, ['_set', 'setRange', 'length']);
dart.defineExtensionNames([
'runtimeType',
'sublist'
@@ -15976,7 +15975,7 @@
dart.registerExtension(dart.global.Float64Array, _native_typed_data.NativeFloat64List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeInt16List = class NativeInt16List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -15993,7 +15992,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Int16List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16021,7 +16020,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeInt16List, [_native_typed_data.NativeByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16034,7 +16033,7 @@
dart.registerExtension(dart.global.Int16Array, _native_typed_data.NativeInt16List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeInt32List = class NativeInt32List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16051,7 +16050,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Int32List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16079,7 +16078,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeInt32List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16092,7 +16091,7 @@
dart.registerExtension(dart.global.Int32Array, _native_typed_data.NativeInt32List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeInt8List = class NativeInt8List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16109,7 +16108,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Int8List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16137,7 +16136,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeInt8List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16150,7 +16149,7 @@
dart.registerExtension(dart.global.Int8Array, _native_typed_data.NativeInt8List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint16List = class NativeUint16List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16167,7 +16166,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Uint16List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16195,7 +16194,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint16List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16208,7 +16207,7 @@
dart.registerExtension(dart.global.Uint16Array, _native_typed_data.NativeUint16List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint32List = class NativeUint32List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16225,7 +16224,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Uint32List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16253,7 +16252,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint32List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16267,7 +16266,7 @@
dart.defineExtensionNames([
'runtimeType',
'length',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint8ClampedList = class NativeUint8ClampedList extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16290,7 +16289,7 @@
set [dartx.length](value) {
super[dartx.length] = value;
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16318,7 +16317,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint8ClampedList, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16333,7 +16332,7 @@
dart.defineExtensionNames([
'runtimeType',
'length',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint8List = class NativeUint8List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16356,7 +16355,7 @@
set [dartx.length](value) {
super[dartx.length] = value;
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16384,7 +16383,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint8List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16397,8 +16396,8 @@
dart.registerExtension(dart.global.Uint8Array, _native_typed_data.NativeUint8List);
_native_typed_data.NativeFloat32x4 = class NativeFloat32x4 extends core.Object {
static _truncate(x) {
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, core.num._check(x));
- return _native_typed_data.NativeFloat32x4._list[dartx.get](0);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, core.num._check(x));
+ return _native_typed_data.NativeFloat32x4._list[dartx._get](0);
}
new(x, y, z, w) {
this.x = core.double._check(_native_typed_data.NativeFloat32x4._truncate(x));
@@ -16417,11 +16416,11 @@
NativeFloat32x4.prototype._truncated.call(this, 0.0, 0.0, 0.0, 0.0);
}
static fromInt32x4Bits(i) {
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](0, i.x);
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](1, i.y);
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](2, i.z);
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](3, i.w);
- return new _native_typed_data.NativeFloat32x4._truncated(_native_typed_data.NativeFloat32x4._list[dartx.get](0), _native_typed_data.NativeFloat32x4._list[dartx.get](1), _native_typed_data.NativeFloat32x4._list[dartx.get](2), _native_typed_data.NativeFloat32x4._list[dartx.get](3));
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](0, i.x);
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](1, i.y);
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](2, i.z);
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](3, i.w);
+ return new _native_typed_data.NativeFloat32x4._truncated(_native_typed_data.NativeFloat32x4._list[dartx._get](0), _native_typed_data.NativeFloat32x4._list[dartx._get](1), _native_typed_data.NativeFloat32x4._list[dartx._get](2), _native_typed_data.NativeFloat32x4._list[dartx._get](3));
}
fromFloat64x2(v) {
NativeFloat32x4.prototype._truncated.call(this, core.double._check(_native_typed_data.NativeFloat32x4._truncate(v.x)), core.double._check(_native_typed_data.NativeFloat32x4._truncate(v.y)), 0.0, 0.0);
@@ -16448,7 +16447,7 @@
let _w = dart.notNull(this.w) + dart.notNull(other.w);
return new _native_typed_data.NativeFloat32x4._doubles(_x, _y, _z, _w);
}
- ['unary-']() {
+ _negate() {
return new _native_typed_data.NativeFloat32x4._truncated(-dart.notNull(this.x), -dart.notNull(this.y), -dart.notNull(this.z), -dart.notNull(this.w));
}
['-'](other) {
@@ -16554,46 +16553,46 @@
get signMask() {
let view = _native_typed_data.NativeFloat32x4._uint32view;
let mx = null, my = null, mz = null, mw = null;
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, this.w);
- mx = (dart.notNull(view[dartx.get](0)) & 2147483648) >>> 31;
- my = (dart.notNull(view[dartx.get](1)) & 2147483648) >>> 30;
- mz = (dart.notNull(view[dartx.get](2)) & 2147483648) >>> 29;
- mw = (dart.notNull(view[dartx.get](3)) & 2147483648) >>> 28;
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, this.w);
+ mx = (dart.notNull(view[dartx._get](0)) & 2147483648) >>> 31;
+ my = (dart.notNull(view[dartx._get](1)) & 2147483648) >>> 30;
+ mz = (dart.notNull(view[dartx._get](2)) & 2147483648) >>> 29;
+ mw = (dart.notNull(view[dartx._get](3)) & 2147483648) >>> 28;
return core.int._check(dart.dsend(dart.dsend(dart.dsend(mx, '|', my), '|', mz), '|', mw));
}
shuffle(mask) {
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- let _z = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ let _z = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
}
shuffleMix(other, mask) {
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, other.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, other.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, other.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, other.w);
- let _z = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, other.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, other.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, other.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, other.w);
+ let _z = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
}
withX(newX) {
@@ -16669,7 +16668,7 @@
getters: () => ({signMask: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
'+': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
- 'unary-': dart.definiteFunctionType(typed_data.Float32x4, []),
+ _negate: dart.definiteFunctionType(typed_data.Float32x4, []),
'-': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
'*': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
'/': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
@@ -16711,8 +16710,8 @@
});
_native_typed_data.NativeInt32x4 = class NativeInt32x4 extends core.Object {
static _truncate(x) {
- _native_typed_data.NativeInt32x4._list[dartx.set](0, core.int._check(x));
- return _native_typed_data.NativeInt32x4._list[dartx.get](0);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, core.int._check(x));
+ return _native_typed_data.NativeInt32x4._list[dartx._get](0);
}
new(x, y, z, w) {
this.x = core.int._check(_native_typed_data.NativeInt32x4._truncate(x));
@@ -16732,12 +16731,12 @@
}
static fromFloat32x4Bits(f) {
let floatList = _native_typed_data.NativeFloat32x4._list;
- floatList[dartx.set](0, f.x);
- floatList[dartx.set](1, f.y);
- floatList[dartx.set](2, f.z);
- floatList[dartx.set](3, f.w);
+ floatList[dartx._set](0, f.x);
+ floatList[dartx._set](1, f.y);
+ floatList[dartx._set](2, f.z);
+ floatList[dartx._set](3, f.w);
let view = _native_typed_data.NativeInt32List._check(floatList[dartx.buffer][dartx.asInt32List]());
- return new _native_typed_data.NativeInt32x4._truncated(view[dartx.get](0), view[dartx.get](1), view[dartx.get](2), view[dartx.get](3));
+ return new _native_typed_data.NativeInt32x4._truncated(view[dartx._get](0), view[dartx._get](1), view[dartx._get](2), view[dartx._get](3));
}
_truncated(x, y, z, w) {
this.x = x;
@@ -16763,7 +16762,7 @@
['-'](other) {
return new _native_typed_data.NativeInt32x4._truncated(this.x - other.x | 0, this.y - other.y | 0, this.z - other.z | 0, this.w - other.w | 0);
}
- ['unary-']() {
+ _negate() {
return new _native_typed_data.NativeInt32x4._truncated(-this.x | 0, -this.y | 0, -this.z | 0, -this.w | 0);
}
get signMask() {
@@ -16777,32 +16776,32 @@
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeInt32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeInt32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeInt32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeInt32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- let _z = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeInt32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeInt32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeInt32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ let _z = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
}
shuffleMix(other, mask) {
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeInt32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeInt32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeInt32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeInt32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- _native_typed_data.NativeInt32x4._list[dartx.set](0, other.x);
- _native_typed_data.NativeInt32x4._list[dartx.set](1, other.y);
- _native_typed_data.NativeInt32x4._list[dartx.set](2, other.z);
- _native_typed_data.NativeInt32x4._list[dartx.set](3, other.w);
- let _z = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeInt32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeInt32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeInt32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, other.x);
+ _native_typed_data.NativeInt32x4._list[dartx._set](1, other.y);
+ _native_typed_data.NativeInt32x4._list[dartx._set](2, other.z);
+ _native_typed_data.NativeInt32x4._list[dartx._set](3, other.w);
+ let _z = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
}
withX(x) {
@@ -16852,31 +16851,31 @@
select(trueValue, falseValue) {
let floatList = _native_typed_data.NativeFloat32x4._list;
let intView = _native_typed_data.NativeFloat32x4._uint32view;
- floatList[dartx.set](0, trueValue.x);
- floatList[dartx.set](1, trueValue.y);
- floatList[dartx.set](2, trueValue.z);
- floatList[dartx.set](3, trueValue.w);
- let stx = intView[dartx.get](0);
- let sty = intView[dartx.get](1);
- let stz = intView[dartx.get](2);
- let stw = intView[dartx.get](3);
- floatList[dartx.set](0, falseValue.x);
- floatList[dartx.set](1, falseValue.y);
- floatList[dartx.set](2, falseValue.z);
- floatList[dartx.set](3, falseValue.w);
- let sfx = intView[dartx.get](0);
- let sfy = intView[dartx.get](1);
- let sfz = intView[dartx.get](2);
- let sfw = intView[dartx.get](3);
+ floatList[dartx._set](0, trueValue.x);
+ floatList[dartx._set](1, trueValue.y);
+ floatList[dartx._set](2, trueValue.z);
+ floatList[dartx._set](3, trueValue.w);
+ let stx = intView[dartx._get](0);
+ let sty = intView[dartx._get](1);
+ let stz = intView[dartx._get](2);
+ let stw = intView[dartx._get](3);
+ floatList[dartx._set](0, falseValue.x);
+ floatList[dartx._set](1, falseValue.y);
+ floatList[dartx._set](2, falseValue.z);
+ floatList[dartx._set](3, falseValue.w);
+ let sfx = intView[dartx._get](0);
+ let sfy = intView[dartx._get](1);
+ let sfz = intView[dartx._get](2);
+ let sfw = intView[dartx._get](3);
let _x = (dart.notNull(this.x) & dart.notNull(stx) | ~dart.notNull(this.x) & dart.notNull(sfx)) >>> 0;
let _y = (dart.notNull(this.y) & dart.notNull(sty) | ~dart.notNull(this.y) & dart.notNull(sfy)) >>> 0;
let _z = (dart.notNull(this.z) & dart.notNull(stz) | ~dart.notNull(this.z) & dart.notNull(sfz)) >>> 0;
let _w = (dart.notNull(this.w) & dart.notNull(stw) | ~dart.notNull(this.w) & dart.notNull(sfw)) >>> 0;
- intView[dartx.set](0, _x);
- intView[dartx.set](1, _y);
- intView[dartx.set](2, _z);
- intView[dartx.set](3, _w);
- return new _native_typed_data.NativeFloat32x4._truncated(floatList[dartx.get](0), floatList[dartx.get](1), floatList[dartx.get](2), floatList[dartx.get](3));
+ intView[dartx._set](0, _x);
+ intView[dartx._set](1, _y);
+ intView[dartx._set](2, _z);
+ intView[dartx._set](3, _w);
+ return new _native_typed_data.NativeFloat32x4._truncated(floatList[dartx._get](0), floatList[dartx._get](1), floatList[dartx._get](2), floatList[dartx._get](3));
}
};
dart.defineNamedConstructor(_native_typed_data.NativeInt32x4, 'bool');
@@ -16908,7 +16907,7 @@
'^': dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4]),
'+': dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4]),
'-': dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4]),
- 'unary-': dart.definiteFunctionType(typed_data.Int32x4, []),
+ _negate: dart.definiteFunctionType(typed_data.Int32x4, []),
shuffle: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
shuffleMix: dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4, core.int]),
withX: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
@@ -16956,7 +16955,7 @@
['+'](other) {
return new _native_typed_data.NativeFloat64x2._doubles(dart.notNull(this.x) + dart.notNull(other.x), dart.notNull(this.y) + dart.notNull(other.y));
}
- ['unary-']() {
+ _negate() {
return new _native_typed_data.NativeFloat64x2._doubles(-dart.notNull(this.x), -dart.notNull(this.y));
}
['-'](other) {
@@ -16989,10 +16988,10 @@
}
get signMask() {
let view = _native_typed_data.NativeFloat64x2._uint32View;
- _native_typed_data.NativeFloat64x2._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat64x2._list[dartx.set](1, this.y);
- let mx = (dart.notNull(view[dartx.get](1)) & 2147483648) >>> 31;
- let my = (dart.notNull(view[dartx.get](3)) & 2147483648) >>> 31;
+ _native_typed_data.NativeFloat64x2._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat64x2._list[dartx._set](1, this.y);
+ let mx = (dart.notNull(view[dartx._get](1)) & 2147483648) >>> 31;
+ let my = (dart.notNull(view[dartx._get](3)) & 2147483648) >>> 31;
return (mx | my << 1) >>> 0;
}
withX(x) {
@@ -17033,7 +17032,7 @@
getters: () => ({signMask: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
'+': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
- 'unary-': dart.definiteFunctionType(typed_data.Float64x2, []),
+ _negate: dart.definiteFunctionType(typed_data.Float64x2, []),
'-': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
'*': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
'/': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
@@ -18400,7 +18399,7 @@
future.then(dart.dynamic)(dart.fn(value => {
remaining--;
if (values != null) {
- values[dartx.set](pos, value);
+ values[dartx._set](pos, value);
if (remaining == 0) {
result[_completeWithValue](values);
}
@@ -22425,13 +22424,13 @@
}
};
}
- get(key) {
- let result = this[_map$][dartx.get](key);
+ _get(key) {
+ let result = this[_map$][dartx._get](key);
if (result != null || dart.test(this[_map$][dartx.containsKey](key))) return result;
if (this.parent != null) {
- let value = this.parent.get(key);
+ let value = this.parent._get(key);
if (value != null) {
- this[_map$][dartx.set](key, value);
+ this[_map$][dartx._set](key, value);
}
return value;
}
@@ -22579,7 +22578,7 @@
bindCallback: dart.definiteFunctionType(R => [async.ZoneCallback$(R), [dart.functionType(R, [])], {runGuarded: core.bool}]),
bindUnaryCallback: dart.definiteFunctionType((R, T) => [async.ZoneUnaryCallback$(R, T), [dart.functionType(R, [T])], {runGuarded: core.bool}]),
bindBinaryCallback: dart.definiteFunctionType((R, T1, T2) => [async.ZoneBinaryCallback$(R, T1, T2), [dart.functionType(R, [T1, T2])], {runGuarded: core.bool}]),
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
handleUncaughtError: dart.definiteFunctionType(R => [R, [dart.dynamic, core.StackTrace]]),
fork: dart.definiteFunctionType(async.Zone, [], {specification: async.ZoneSpecification, zoneValues: core.Map}),
run: dart.definiteFunctionType(R => [R, [dart.functionType(R, [])]]),
@@ -22861,7 +22860,7 @@
}
};
}
- get(key) {
+ _get(key) {
return null;
}
handleUncaughtError(R) {
@@ -22951,7 +22950,7 @@
bindCallback: dart.definiteFunctionType(R => [async.ZoneCallback$(R), [dart.functionType(R, [])], {runGuarded: core.bool}]),
bindUnaryCallback: dart.definiteFunctionType((R, T) => [async.ZoneUnaryCallback$(R, T), [dart.functionType(R, [T])], {runGuarded: core.bool}]),
bindBinaryCallback: dart.definiteFunctionType((R, T1, T2) => [async.ZoneBinaryCallback$(R, T1, T2), [dart.functionType(R, [T1, T2])], {runGuarded: core.bool}]),
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
handleUncaughtError: dart.definiteFunctionType(R => [R, [dart.dynamic, core.StackTrace]]),
fork: dart.definiteFunctionType(async.Zone, [], {specification: async.ZoneSpecification, zoneValues: core.Map}),
run: dart.definiteFunctionType(R => [R, [dart.functionType(R, [])]]),
@@ -23065,7 +23064,7 @@
return new (_HashMapKeyIterableOfK())(this);
}
get values() {
- return MappedIterableOfK$V().new(this.keys, dart.fn(each => this.get(each), KToV()));
+ return MappedIterableOfK$V().new(this.keys, dart.fn(each => this._get(each), KToV()));
}
containsKey(key) {
if (dart.test(collection._HashMap._isStringKey(key))) {
@@ -23085,15 +23084,15 @@
return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
}
containsValue(value) {
- return this[_computeKeys]()[dartx.any](dart.fn(each => dart.equals(this.get(each), value), KTobool()));
+ return this[_computeKeys]()[dartx.any](dart.fn(each => dart.equals(this._get(each), value), KTobool()));
}
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
- get(key) {
+ _get(key) {
if (dart.test(collection._HashMap._isStringKey(key))) {
let strings = this[_strings$];
return V._check(strings == null ? null : collection._HashMap._getTableEntry(strings, key));
@@ -23111,7 +23110,7 @@
let index = this[_findBucketIndex](bucket, key);
return V._check(dart.notNull(index) < 0 ? null : bucket[dart.notNull(index) + 1]);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
if (dart.test(collection._HashMap._isStringKey(key))) {
@@ -23152,9 +23151,9 @@
putIfAbsent(key, ifAbsent) {
K._check(key);
VoidToV()._check(ifAbsent);
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
@@ -23186,7 +23185,7 @@
let keys = this[_computeKeys]();
for (let i = 0, length = keys[dartx.length]; i < dart.notNull(length); i++) {
let key = keys[i];
- action(K._check(key), this.get(key));
+ action(K._check(key), this._get(key));
if (keys !== this[_keys]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -23324,9 +23323,9 @@
[_containsKey]: dart.definiteFunctionType(core.bool, [core.Object]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
- get: dart.definiteFunctionType(V, [core.Object]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
[_get]: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
[_set]: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
remove: dart.definiteFunctionType(V, [core.Object]),
@@ -23355,8 +23354,8 @@
'containsKey',
'containsValue',
'addAll',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -23403,11 +23402,11 @@
this[_validKey] = validKey != null ? validKey : dart.fn(v => K.is(v), ObjectTobool());
super.new();
}
- get(key) {
+ _get(key) {
if (!dart.test(this[_validKey](key))) return null;
return super[_get](key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
super[_set](key, value);
@@ -23444,12 +23443,12 @@
[_validKey]: _PredicateOfObject()
}),
methods: () => ({
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
remove: dart.definiteFunctionType(V, [core.Object])
})
});
- dart.defineExtensionMembers(_CustomHashMap, ['get', 'set', 'containsKey', 'remove']);
+ dart.defineExtensionMembers(_CustomHashMap, ['_get', '_set', 'containsKey', 'remove']);
return _CustomHashMap;
});
collection._CustomHashMap = _CustomHashMap();
@@ -23626,13 +23625,13 @@
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
- get(key) {
+ _get(key) {
return this[_map$0].get(key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
this[_map$0].set(key, value);
@@ -23642,13 +23641,13 @@
putIfAbsent(key, ifAbsent) {
K._check(key);
VoidToV()._check(ifAbsent);
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
- let value = this.get(key);
+ let value = this._get(key);
this[_map$0].delete(key);
this[_modified$]();
return value;
@@ -23693,8 +23692,8 @@
}),
methods: () => ({
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
remove: dart.definiteFunctionType(V, [core.Object]),
forEach: dart.definiteFunctionType(dart.void, [KAndVTovoid()]),
@@ -23705,8 +23704,8 @@
'containsKey',
'containsValue',
'addAll',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -23852,11 +23851,11 @@
this[_validKey] = validKey != null ? validKey : dart.fn(v => K.is(v), ObjectTobool());
super.new();
}
- get(key) {
+ _get(key) {
if (!dart.test(this[_validKey](key))) return null;
return super.internalGet(key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
super.internalSet(key, value);
@@ -23891,12 +23890,12 @@
[_validKey]: _PredicateOfObject()
}),
methods: () => ({
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
remove: dart.definiteFunctionType(V, [core.Object])
})
});
- dart.defineExtensionMembers(_LinkedCustomHashMap, ['get', 'set', 'containsKey', 'remove']);
+ dart.defineExtensionMembers(_LinkedCustomHashMap, ['_get', '_set', 'containsKey', 'remove']);
return _LinkedCustomHashMap;
});
collection._LinkedCustomHashMap = _LinkedCustomHashMap();
@@ -23997,7 +23996,7 @@
})() : ListOfE().new(this.length);
let i = 0;
for (let element of this)
- result[dartx.set](i++, element);
+ result[dartx._set](i++, element);
return result;
}
map(T) {
@@ -24333,7 +24332,7 @@
let bucket = this[_getBucket$](rest, object);
let index = this[_findBucketIndex](bucket, object);
if (dart.notNull(index) < 0) return null;
- return bucket[dartx.get](index);
+ return bucket[dartx._get](index);
}
add(element) {
E._check(element);
@@ -24759,7 +24758,7 @@
let bucket = this[_getBucket$](rest, object);
let index = this[_findBucketIndex](bucket, object);
if (dart.notNull(index) < 0) return null;
- return bucket[dartx.get](index)[_element];
+ return bucket[dartx._get](index)[_element];
}
forEach(action) {
let cell = this[_first$];
@@ -25191,7 +25190,7 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
return this[_source$0][dartx.elementAt](index);
}
}
@@ -25199,9 +25198,9 @@
constructors: () => ({new: dart.definiteFunctionType(collection.UnmodifiableListView$(E), [IterableOfE()])}),
fields: () => ({[_source$0]: IterableOfE()}),
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
- methods: () => ({get: dart.definiteFunctionType(E, [core.int])})
+ methods: () => ({_get: dart.definiteFunctionType(E, [core.int])})
});
- dart.defineExtensionMembers(UnmodifiableListView, ['get', 'length']);
+ dart.defineExtensionMembers(UnmodifiableListView, ['_get', 'length']);
return UnmodifiableListView;
});
collection.UnmodifiableListView = UnmodifiableListView();
@@ -25270,7 +25269,7 @@
static from(other) {
let result = HashMapOfK$V().new();
other[dartx.forEach](dart.fn((k, v) => {
- result.set(K.as(k), V.as(v));
+ result._set(K.as(k), V.as(v));
}, dynamicAnddynamicTovoid$()));
return result;
}
@@ -25640,7 +25639,7 @@
});
collection._isToStringVisiting = function(o) {
for (let i = 0; i < dart.notNull(collection._toStringVisiting[dartx.length]); i++) {
- if (core.identical(o, collection._toStringVisiting[dartx.get](i))) return true;
+ if (core.identical(o, collection._toStringVisiting[dartx._get](i))) return true;
}
return false;
};
@@ -25822,7 +25821,7 @@
static from(other) {
let result = LinkedHashMapOfK$V().new();
other[dartx.forEach](dart.fn((k, v) => {
- result.set(K.as(k), V.as(v));
+ result._set(K.as(k), V.as(v));
}, dynamicAnddynamicTovoid$()));
return result;
}
@@ -26189,18 +26188,18 @@
class MapMixin extends core.Object {
forEach(action) {
for (let key of this.keys) {
- action(key, this.get(key));
+ action(key, this._get(key));
}
}
addAll(other) {
MapOfK$V()._check(other);
for (let key of other[dartx.keys]) {
- this.set(key, other[dartx.get](key));
+ this._set(key, other[dartx._get](key));
}
}
containsValue(value) {
for (let key of this.keys) {
- if (dart.equals(this.get(key), value)) return true;
+ if (dart.equals(this._get(key), value)) return true;
}
return false;
}
@@ -26208,9 +26207,9 @@
K._check(key);
VoidToV()._check(ifAbsent);
if (dart.test(this.containsKey(key))) {
- return this.get(key);
+ return this._get(key);
}
- return this.set(key, ifAbsent());
+ return this._set(key, ifAbsent());
}
containsKey(key) {
return this.keys[dartx.contains](key);
@@ -26271,7 +26270,7 @@
let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
let VoidToV = () => (VoidToV = dart.constFn(dart.functionType(V, [])))();
class _UnmodifiableMapMixin extends core.Object {
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
@@ -26297,7 +26296,7 @@
_UnmodifiableMapMixin[dart.implements] = () => [MapOfK$V()];
dart.setSignature(_UnmodifiableMapMixin, {
methods: () => ({
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
clear: dart.definiteFunctionType(dart.void, []),
remove: dart.definiteFunctionType(V, [core.Object]),
@@ -26305,7 +26304,7 @@
})
});
dart.defineExtensionMembers(_UnmodifiableMapMixin, [
- 'set',
+ '_set',
'addAll',
'clear',
'remove',
@@ -26341,13 +26340,13 @@
return this[_map$0][dartx.isNotEmpty];
}
get first() {
- return this[_map$0][dartx.get](this[_map$0][dartx.keys][dartx.first]);
+ return this[_map$0][dartx._get](this[_map$0][dartx.keys][dartx.first]);
}
get single() {
- return this[_map$0][dartx.get](this[_map$0][dartx.keys][dartx.single]);
+ return this[_map$0][dartx._get](this[_map$0][dartx.keys][dartx.single]);
}
get last() {
- return this[_map$0][dartx.get](this[_map$0][dartx.keys][dartx.last]);
+ return this[_map$0][dartx._get](this[_map$0][dartx.keys][dartx.last]);
}
get iterator() {
return new (_MapBaseValueIteratorOfK$V())(this[_map$0]);
@@ -26388,7 +26387,7 @@
}
moveNext() {
if (dart.test(this[_keys].moveNext())) {
- this[_current$2] = this[_map$0][dartx.get](this[_keys].current);
+ this[_current$2] = this[_map$0][dartx._get](this[_keys].current);
return true;
}
this[_current$2] = null;
@@ -26421,13 +26420,13 @@
new(map) {
this[_map$0] = map;
}
- get(key) {
- return this[_map$0][dartx.get](key);
+ _get(key) {
+ return this[_map$0][dartx._get](key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
- this[_map$0][dartx.set](key, value);
+ this[_map$0][dartx._set](key, value);
return value;
}
addAll(other) {
@@ -26486,8 +26485,8 @@
values: dart.definiteFunctionType(core.Iterable$(V), [])
}),
methods: () => ({
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
clear: dart.definiteFunctionType(dart.void, []),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
@@ -26498,8 +26497,8 @@
})
});
dart.defineExtensionMembers(MapView, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'addAll',
'clear',
'putIfAbsent',
@@ -26544,10 +26543,10 @@
}
static putIfAbsent(map, key, ifAbsent) {
if (dart.test(map[dartx.containsKey](key))) {
- return map[dartx.get](key);
+ return map[dartx._get](key);
}
let v = ifAbsent();
- map[dartx.set](key, v);
+ map[dartx._set](key, v);
return v;
}
static clear(map) {
@@ -26557,11 +26556,11 @@
}
static forEach(map, f) {
for (let k of map[dartx.keys]) {
- dart.dcall(f, k, map[dartx.get](k));
+ dart.dcall(f, k, map[dartx._get](k));
}
}
static getValues(map) {
- return map[dartx.keys][dartx.map](dart.dynamic)(dart.fn(key => map[dartx.get](key), dynamicTodynamic$()));
+ return map[dartx.keys][dartx.map](dart.dynamic)(dart.fn(key => map[dartx._get](key), dynamicTodynamic$()));
}
static length(map) {
return map[dartx.keys][dartx.length];
@@ -26604,7 +26603,7 @@
if (key == null) key = collection.Maps._id;
if (value == null) value = collection.Maps._id;
for (let element of iterable) {
- map[dartx.set](dart.dcall(key, element), dart.dcall(value, element));
+ map[dartx._set](dart.dcall(key, element), dart.dcall(value, element));
}
}
static _fillMapWithIterables(map, keys, values) {
@@ -26613,7 +26612,7 @@
let hasNextKey = keyIterator.moveNext();
let hasNextValue = valueIterator.moveNext();
while (dart.test(hasNextKey) && dart.test(hasNextValue)) {
- map[dartx.set](keyIterator.current, valueIterator.current);
+ map[dartx._set](keyIterator.current, valueIterator.current);
hasNextKey = keyIterator.moveNext();
hasNextValue = valueIterator.moveNext();
}
@@ -27152,7 +27151,7 @@
let queue = new (ListQueueOfE())(dart.notNull(length) + 1);
dart.assert(dart.notNull(queue[_table][dartx.length]) > dart.notNull(length));
for (let i = 0; i < dart.notNull(length); i++) {
- queue[_table][dartx.set](i, E.as(elements[dartx.get](i)));
+ queue[_table][dartx._set](i, E.as(elements[dartx._get](i)));
}
queue[_tail] = length;
return queue;
@@ -27174,7 +27173,7 @@
forEach(action) {
let modificationCount = this[_modificationCount];
for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0) {
- action(this[_table][dartx.get](i));
+ action(this[_table][dartx._get](i));
this[_checkModification](modificationCount);
}
}
@@ -27186,20 +27185,20 @@
}
get first() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
- return this[_table][dartx.get](this[_head]);
+ return this[_table][dartx._get](this[_head]);
}
get last() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
- return this[_table][dartx.get]((dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
+ return this[_table][dartx._get]((dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
}
get single() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
if (dart.notNull(this.length) > 1) dart.throw(_internal.IterableElementError.tooMany());
- return this[_table][dartx.get](this[_head]);
+ return this[_table][dartx._get](this[_head]);
}
elementAt(index) {
core.RangeError.checkValidIndex(index, this);
- return this[_table][dartx.get]((dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
+ return this[_table][dartx._get]((dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
}
toList(opts) {
let growable = opts && 'growable' in opts ? opts.growable : true;
@@ -27247,7 +27246,7 @@
}
remove(value) {
for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0) {
- let element = this[_table][dartx.get](i);
+ let element = this[_table][dartx._get](i);
if (dart.equals(element, value)) {
this[_remove](i);
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ -27260,7 +27259,7 @@
let modificationCount = this[_modificationCount];
let i = this[_head];
while (i != this[_tail]) {
- let element = this[_table][dartx.get](i);
+ let element = this[_table][dartx._get](i);
let remove = core.identical(removeMatching, test(element));
this[_checkModification](modificationCount);
if (remove) {
@@ -27280,7 +27279,7 @@
clear() {
if (this[_head] != this[_tail]) {
for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0) {
- this[_table][dartx.set](i, null);
+ this[_table][dartx._set](i, null);
}
this[_head] = this[_tail] = 0;
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ -27296,15 +27295,15 @@
addFirst(value) {
E._check(value);
this[_head] = (dart.notNull(this[_head]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
- this[_table][dartx.set](this[_head], value);
+ this[_table][dartx._set](this[_head], value);
if (this[_head] == this[_tail]) this[_grow]();
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
}
removeFirst() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
- let result = this[_table][dartx.get](this[_head]);
- this[_table][dartx.set](this[_head], null);
+ let result = this[_table][dartx._get](this[_head]);
+ this[_table][dartx._set](this[_head], null);
this[_head] = (dart.notNull(this[_head]) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
return result;
}
@@ -27312,8 +27311,8 @@
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
this[_tail] = (dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
- let result = this[_table][dartx.get](this[_tail]);
- this[_table][dartx.set](this[_tail], null);
+ let result = this[_table][dartx._get](this[_tail]);
+ this[_table][dartx._set](this[_tail], null);
return result;
}
static _isPowerOf2(number) {
@@ -27335,7 +27334,7 @@
}
[_add$0](element) {
E._check(element);
- this[_table][dartx.set](this[_tail], element);
+ this[_table][dartx._set](this[_tail], element);
this[_tail] = (dart.notNull(this[_tail]) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
if (this[_head] == this[_tail]) this[_grow]();
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ -27348,10 +27347,10 @@
let i = offset;
while (i != this[_head]) {
let prevOffset = (dart.notNull(i) - 1 & mask) >>> 0;
- this[_table][dartx.set](i, this[_table][dartx.get](prevOffset));
+ this[_table][dartx._set](i, this[_table][dartx._get](prevOffset));
i = prevOffset;
}
- this[_table][dartx.set](this[_head], null);
+ this[_table][dartx._set](this[_head], null);
this[_head] = (dart.notNull(this[_head]) + 1 & mask) >>> 0;
return (dart.notNull(offset) + 1 & mask) >>> 0;
} else {
@@ -27359,10 +27358,10 @@
let i = offset;
while (i != this[_tail]) {
let nextOffset = (dart.notNull(i) + 1 & mask) >>> 0;
- this[_table][dartx.set](i, this[_table][dartx.get](nextOffset));
+ this[_table][dartx._set](i, this[_table][dartx._get](nextOffset));
i = nextOffset;
}
- this[_table][dartx.set](this[_tail], null);
+ this[_table][dartx._set](this[_tail], null);
return offset;
}
}
@@ -27484,7 +27483,7 @@
this[_current$2] = null;
return false;
}
- this[_current$2] = this[_queue][_table][dartx.get](this[_position]);
+ this[_current$2] = this[_queue][_table][dartx._get](this[_position]);
this[_position] = (dart.notNull(this[_position]) + 1 & dart.notNull(this[_queue][_table][dartx.length]) - 1) >>> 0;
return true;
}
@@ -27759,7 +27758,7 @@
if (isValidKey === void 0) isValidKey = null;
let result = new (SplayTreeMapOfK$V())(compare, isValidKey);
other[dartx.forEach](dart.fn((k, v) => {
- result.set(K.as(k), V.as(v));
+ result._set(K.as(k), V.as(v));
}, dynamicAnddynamicTovoid$()));
return result;
}
@@ -27791,7 +27790,7 @@
this[_validKey] = null;
super.new();
}
- get(key) {
+ _get(key) {
if (!dart.test(dart.dcall(this[_validKey], key))) return null;
if (this[_root] != null) {
let comp = this[_splay](K.as(key));
@@ -27807,7 +27806,7 @@
if (mapRoot != null) return mapRoot.value;
return null;
}
- set(key, value) {
+ _set(key, value) {
(() => {
K._check(key);
V._check(value);
@@ -27845,7 +27844,7 @@
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
get isEmpty() {
@@ -27956,9 +27955,9 @@
}),
methods: () => ({
[_compare]: dart.definiteFunctionType(core.int, [K, K]),
- get: dart.definiteFunctionType(V, [core.Object]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
remove: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
forEach: dart.definiteFunctionType(dart.void, [KAndVTovoid()]),
@@ -27972,9 +27971,9 @@
})
});
dart.defineExtensionMembers(SplayTreeMap, [
- 'get',
+ '_get',
'remove',
- 'set',
+ '_set',
'putIfAbsent',
'addAll',
'forEach',
@@ -28449,7 +28448,7 @@
let processed = map[_processed];
let keys = map[_computeKeys$]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
+ let key = keys[dartx._get](i);
let revived = dart.dcall(reviver, key, walk(e[key]));
processed[key] = revived;
}
@@ -28486,9 +28485,9 @@
this[_original] = original;
this[_data] = null;
}
- get(key) {
+ _get(key) {
if (dart.test(this[_isUpgraded])) {
- return this[_upgradedMap][dartx.get](key);
+ return this[_upgradedMap][dartx._get](key);
} else if (!(typeof key == 'string')) {
return null;
} else {
@@ -28512,11 +28511,11 @@
}
get values() {
if (dart.test(this[_isUpgraded])) return this[_upgradedMap][dartx.values];
- return MappedIterableOfString$dynamic().new(this[_computeKeys$](), dart.fn(each => this.get(each), dynamicTodynamic$()));
+ return MappedIterableOfString$dynamic().new(this[_computeKeys$](), dart.fn(each => this._get(each), dynamicTodynamic$()));
}
- set(key, value) {
+ _set(key, value) {
if (dart.test(this[_isUpgraded])) {
- this[_upgradedMap][dartx.set](key, value);
+ this[_upgradedMap][dartx._set](key, value);
} else if (dart.test(this.containsKey(key))) {
let processed = this[_processed];
convert._JsonMap._setProperty(processed, core.String._check(key), value);
@@ -28525,21 +28524,21 @@
convert._JsonMap._setProperty(original, core.String._check(key), null);
}
} else {
- this[_upgrade]()[dartx.set](key, value);
+ this[_upgrade]()[dartx._set](key, value);
}
return value;
}
addAll(other) {
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, dynamicAnddynamicTovoid$()));
}
containsValue(value) {
if (dart.test(this[_isUpgraded])) return this[_upgradedMap][dartx.containsValue](value);
let keys = this[_computeKeys$]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
- if (dart.equals(this.get(key), value)) return true;
+ let key = keys[dartx._get](i);
+ if (dart.equals(this._get(key), value)) return true;
}
return false;
}
@@ -28549,9 +28548,9 @@
return convert._JsonMap._hasProperty(this[_original], core.String._check(key));
}
putIfAbsent(key, ifAbsent) {
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
@@ -28573,7 +28572,7 @@
if (dart.test(this[_isUpgraded])) return this[_upgradedMap][dartx.forEach](f);
let keys = this[_computeKeys$]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
+ let key = keys[dartx._get](i);
let value = convert._JsonMap._getProperty(this[_processed], key);
if (dart.test(convert._JsonMap._isUnprocessed(value))) {
value = convert._convertJsonToDartLazy(convert._JsonMap._getProperty(this[_original], key));
@@ -28608,8 +28607,8 @@
let result = dart.map();
let keys = this[_computeKeys$]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
- result[dartx.set](key, this.get(key));
+ let key = keys[dartx._get](i);
+ result[dartx._set](key, this._get(key));
}
if (dart.test(keys[dartx.isEmpty])) {
keys[dartx.add](null);
@@ -28663,8 +28662,8 @@
[_upgradedMap]: dart.definiteFunctionType(core.Map, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic]),
addAll: dart.definiteFunctionType(dart.void, [core.Map]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
@@ -28687,8 +28686,8 @@
names: ['_hasProperty', '_getProperty', '_setProperty', '_getPropertyNames', '_isUnprocessed', '_newJavaScriptObject']
});
dart.defineExtensionMembers(convert._JsonMap, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'addAll',
'containsValue',
'containsKey',
@@ -28712,7 +28711,7 @@
return this[_parent].length;
}
elementAt(index) {
- return core.String._check(dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.elementAt](index) : this[_parent][_computeKeys$]()[dartx.get](index));
+ return core.String._check(dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.elementAt](index) : this[_parent][_computeKeys$]()[dartx._get](index));
}
get iterator() {
return dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.iterator] : this[_parent][_computeKeys$]()[dartx.iterator];
@@ -28956,7 +28955,7 @@
let result = ListOfE().new(length);
if (length != 0 && fill != null) {
for (let i = 0; i < dart.notNull(result[dartx.length]); i++) {
- result[dartx.set](i, fill);
+ result[dartx._set](i, fill);
}
}
return result;
@@ -28980,7 +28979,7 @@
result = ListOfE().new(length);
}
for (let i = 0; i < dart.notNull(length); i++) {
- result[dartx.set](i, generator(i));
+ result[dartx._set](i, generator(i));
}
return result;
}
@@ -29019,7 +29018,7 @@
static getByName(name) {
if (name == null) return null;
name = name[dartx.toLowerCase]();
- return convert.Encoding._nameToEncoding[dartx.get](name);
+ return convert.Encoding._nameToEncoding[dartx._get](name);
}
};
dart.addSimpleTypeTests(convert.Encoding);
@@ -29130,7 +29129,7 @@
if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) != 0) {
dart.throw(new core.ArgumentError("String contains invalid characters."));
}
- result[dartx.set](i, codeUnit);
+ result[dartx._set](i, codeUnit);
}
return result;
}
@@ -29209,7 +29208,7 @@
core.RangeError.checkValidRange(start, end, byteCount);
if (end == null) end = byteCount;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
if ((dart.notNull(byte) & ~dart.notNull(this[_subsetMask])) != 0) {
if (!dart.test(this[_allowInvalid])) {
dart.throw(new core.FormatException(dart.str`Invalid value in input: ${byte}`));
@@ -29222,7 +29221,7 @@
[_convertInvalid](bytes, start, end) {
let buffer = new core.StringBuffer();
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let value = bytes[dartx.get](i);
+ let value = bytes[dartx._get](i);
if ((dart.notNull(value) & ~dart.notNull(this[_subsetMask])) != 0) value = 65533;
buffer.writeCharCode(value);
}
@@ -29338,7 +29337,7 @@
addSlice(source, start, end, isLast) {
core.RangeError.checkValidRange(start, end, source[dartx.length]);
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- if ((dart.notNull(source[dartx.get](i)) & ~convert._ASCII_MASK) != 0) {
+ if ((dart.notNull(source[dartx._get](i)) & ~convert._ASCII_MASK) != 0) {
if (dart.notNull(i) > dart.notNull(start)) this[_utf8Sink].addSlice(source, start, i, false);
this[_utf8Sink].add(const$30 || (const$30 = dart.constList([239, 191, 189], core.int)));
start = dart.notNull(i) + 1;
@@ -29369,7 +29368,7 @@
}
add(source) {
for (let i = 0; i < dart.notNull(source[dartx.length]); i++) {
- if ((dart.notNull(source[dartx.get](i)) & ~convert._ASCII_MASK) != 0) {
+ if ((dart.notNull(source[dartx._get](i)) & ~convert._ASCII_MASK) != 0) {
dart.throw(new core.FormatException("Source contains non-ASCII bytes."));
}
}
@@ -29510,27 +29509,27 @@
let expectedChars = 3 - dart.notNull(convert._Base64Encoder._stateCount(state));
let byteOr = 0;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
byteOr = (dart.notNull(byteOr) | dart.notNull(byte)) >>> 0;
bits = (dart.notNull(bits) << 8 | dart.notNull(byte)) & 16777215;
expectedChars--;
if (expectedChars == 0) {
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 18 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 12 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 6 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
@@ -29548,53 +29547,53 @@
}
let i = start;
while (dart.notNull(i) < dart.notNull(end)) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) break;
i = dart.notNull(i) + 1;
}
- dart.throw(new core.ArgumentError.value(bytes, dart.str`Not a byte value at index ${i}: 0x${bytes[dartx.get](i)[dartx.toRadixString](16)}`));
+ dart.throw(new core.ArgumentError.value(bytes, dart.str`Not a byte value at index ${i}: 0x${bytes[dartx._get](i)[dartx.toRadixString](16)}`));
}
static writeFinalChunk(alphabet, output, outputIndex, count, bits) {
dart.assert(dart.notNull(count) > 0);
if (count == 1) {
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 2 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) << 4 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), convert._paddingChar);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), convert._paddingChar);
} else {
dart.assert(count == 2);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 10 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 4 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) << 2 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
@@ -29806,23 +29805,23 @@
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
let char = input[dartx.codeUnitAt](i);
charOr = (dart.notNull(charOr) | dart.notNull(char)) >>> 0;
- let code = convert._Base64Decoder._inverseAlphabet[dartx.get]((dart.notNull(char) & asciiMask) >>> 0);
+ let code = convert._Base64Decoder._inverseAlphabet[dartx._get]((dart.notNull(char) & asciiMask) >>> 0);
if (dart.notNull(code) >= 0) {
bits = (bits[dartx['<<']](bitsPerCharacter) | dart.notNull(code)) & 16777215;
count = dart.notNull(count) + 1 & 3;
if (count == 0) {
dart.assert(dart.notNull(outIndex) + 3 <= dart.notNull(output[dartx.length]));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
})(), (bits[dartx['>>']](16) & eightBitMask) >>> 0);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
})(), (bits[dartx['>>']](8) & eightBitMask) >>> 0);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
@@ -29836,12 +29835,12 @@
if ((dart.notNull(bits) & 3) != 0) {
dart.throw(new core.FormatException("Invalid encoding before padding", input, i));
}
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
})(), bits[dartx['>>']](10));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
@@ -29850,7 +29849,7 @@
if ((dart.notNull(bits) & 15) != 0) {
dart.throw(new core.FormatException("Invalid encoding before padding", input, i));
}
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
@@ -30402,7 +30401,7 @@
[_convert](text, start, end) {
let result = null;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let ch = text[dartx.get](i);
+ let ch = text[dartx._get](i);
let replacement = null;
switch (ch) {
case '&':
@@ -30674,14 +30673,14 @@
}
dart.fn(addChunk, Uint8ListAndintAndintTovoid$());
convert._JsonUtf8Stringifier.stringify(object, this[_indent], this[_toEncodable], this[_bufferSize], addChunk);
- if (bytes[dartx.length] == 1) return bytes[dartx.get](0);
+ if (bytes[dartx.length] == 1) return bytes[dartx._get](0);
let length = 0;
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- length = dart.notNull(length) + dart.notNull(bytes[dartx.get](i)[dartx.length]);
+ length = dart.notNull(length) + dart.notNull(bytes[dartx._get](i)[dartx.length]);
}
let result = typed_data.Uint8List.new(length);
for (let i = 0, offset = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byteList = bytes[dartx.get](i);
+ let byteList = bytes[dartx._get](i);
let end = offset + dart.notNull(byteList[dartx.length]);
result[dartx.setRange](offset, end, byteList);
offset = end;
@@ -30918,7 +30917,7 @@
}
[_checkCycle](object) {
for (let i = 0; i < dart.notNull(this[_seen][dartx.length]); i++) {
- if (core.identical(object, this[_seen][dartx.get](i))) {
+ if (core.identical(object, this[_seen][dartx._get](i))) {
dart.throw(new convert.JsonCyclicError(object));
}
}
@@ -30979,10 +30978,10 @@
writeList(list) {
this.writeString('[');
if (dart.notNull(list[dartx.length]) > 0) {
- this.writeObject(list[dartx.get](0));
+ this.writeObject(list[dartx._get](0));
for (let i = 1; i < dart.notNull(list[dartx.length]); i++) {
this.writeString(',');
- this.writeObject(list[dartx.get](i));
+ this.writeObject(list[dartx._get](i));
}
}
this.writeString(']');
@@ -30999,8 +30998,8 @@
if (!(typeof key == 'string')) {
allStringKeys = false;
}
- keyValueList[dartx.set](i++, key);
- keyValueList[dartx.set](i++, value);
+ keyValueList[dartx._set](i++, key);
+ keyValueList[dartx._set](i++, value);
}, dynamicAnddynamicTovoid$()));
if (!allStringKeys) return false;
this.writeString('{');
@@ -31008,9 +31007,9 @@
for (let i = 0; i < dart.notNull(keyValueList[dartx.length]); i = i + 2) {
this.writeString(separator);
separator = ',"';
- this.writeStringContent(core.String._check(keyValueList[dartx.get](i)));
+ this.writeStringContent(core.String._check(keyValueList[dartx._get](i)));
this.writeString('":');
- this.writeObject(keyValueList[dartx.get](i + 1));
+ this.writeObject(keyValueList[dartx._get](i + 1));
}
this.writeString('}');
return true;
@@ -31076,11 +31075,11 @@
this.writeString('[\n');
this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
this.writeIndentation(this[_indentLevel]);
- this.writeObject(list[dartx.get](0));
+ this.writeObject(list[dartx._get](0));
for (let i = 1; i < dart.notNull(list[dartx.length]); i++) {
this.writeString(',\n');
this.writeIndentation(this[_indentLevel]);
- this.writeObject(list[dartx.get](i));
+ this.writeObject(list[dartx._get](i));
}
this.writeString('\n');
this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
@@ -31100,8 +31099,8 @@
if (!(typeof key == 'string')) {
allStringKeys = false;
}
- keyValueList[dartx.set](i++, key);
- keyValueList[dartx.set](i++, value);
+ keyValueList[dartx._set](i++, key);
+ keyValueList[dartx._set](i++, value);
}, dynamicAnddynamicTovoid$()));
if (!allStringKeys) return false;
this.writeString('{\n');
@@ -31112,9 +31111,9 @@
separator = ",\n";
this.writeIndentation(this[_indentLevel]);
this.writeString('"');
- this.writeStringContent(core.String._check(keyValueList[dartx.get](i)));
+ this.writeStringContent(core.String._check(keyValueList[dartx._get](i)));
this.writeString('": ');
- this.writeObject(keyValueList[dartx.get](i + 1));
+ this.writeObject(keyValueList[dartx._get](i + 1));
}
this.writeString('\n');
this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
@@ -31286,7 +31285,7 @@
this.buffer = typed_data.Uint8List.new(this.bufferSize);
this.index = 0;
}
- this.buffer[dartx.set]((() => {
+ this.buffer[dartx._set]((() => {
let x = this.index;
this.index = dart.notNull(x) + 1;
return x;
@@ -31324,7 +31323,7 @@
let indent = this.indent;
let indentLength = indent[dartx.length];
if (indentLength == 1) {
- let char = indent[dartx.get](0);
+ let char = indent[dartx._get](0);
while (dart.notNull(count) > 0) {
this.writeByte(char);
count = dart.notNull(count) - 1;
@@ -31339,7 +31338,7 @@
this.index = end;
} else {
for (let i = 0; i < dart.notNull(indentLength); i++) {
- this.writeByte(indent[dartx.get](i));
+ this.writeByte(indent[dartx._get](i));
}
}
}
@@ -31448,7 +31447,7 @@
static _checkValidLatin1(source, start, end) {
let mask = 0;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- mask = (dart.notNull(mask) | dart.notNull(source[dartx.get](i))) >>> 0;
+ mask = (dart.notNull(mask) | dart.notNull(source[dartx._get](i))) >>> 0;
}
if (dart.notNull(mask) >= 0 && dart.notNull(mask) <= convert._LATIN1_MASK) {
return;
@@ -31457,7 +31456,7 @@
}
static _reportInvalidLatin1(source, start, end) {
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let char = source[dartx.get](i);
+ let char = source[dartx._get](i);
if (dart.notNull(char) < 0 || dart.notNull(char) > convert._LATIN1_MASK) {
dart.throw(new core.FormatException("Source contains non-Latin-1 characters.", source, i));
}
@@ -31487,7 +31486,7 @@
addSlice(source, start, end, isLast) {
core.RangeError.checkValidRange(start, end, source[dartx.length]);
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let char = source[dartx.get](i);
+ let char = source[dartx._get](i);
if (dart.notNull(char) > convert._LATIN1_MASK || dart.notNull(char) < 0) {
if (dart.notNull(i) > dart.notNull(start)) this[_addSliceToSink](source, start, i, false);
this[_addSliceToSink](const$49 || (const$49 = dart.constList([65533], core.int)), 0, 1, false);
@@ -32027,39 +32026,39 @@
let rune = convert._combineSurrogatePair(leadingSurrogate, nextCodeUnit);
dart.assert(dart.notNull(rune) > convert._THREE_BYTE_LIMIT);
dart.assert(dart.notNull(rune) <= convert._FOUR_BYTE_LIMIT);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (240 | rune[dartx['>>']](18)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) >> 12 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) >> 6 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) & 63);
return true;
} else {
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (224 | leadingSurrogate[dartx['>>']](12)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(leadingSurrogate) >> 6 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32076,7 +32075,7 @@
let codeUnit = str[dartx.codeUnitAt](stringIndex);
if (dart.notNull(codeUnit) <= convert._ONE_BYTE_LIMIT) {
if (dart.notNull(this[_bufferIndex]) >= dart.notNull(this[_buffer][dartx.length])) break;
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32092,12 +32091,12 @@
let rune = codeUnit;
if (dart.notNull(rune) <= convert._TWO_BYTE_LIMIT) {
if (dart.notNull(this[_bufferIndex]) + 1 >= dart.notNull(this[_buffer][dartx.length])) break;
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (192 | rune[dartx['>>']](6)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32105,17 +32104,17 @@
} else {
dart.assert(dart.notNull(rune) <= convert._THREE_BYTE_LIMIT);
if (dart.notNull(this[_bufferIndex]) + 2 >= dart.notNull(this[_buffer][dartx.length])) break;
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (224 | rune[dartx['>>']](12)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) >> 6 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32342,7 +32341,7 @@
if (i == endIndex) {
break loop;
}
- let unit = codeUnits[dartx.get](i);
+ let unit = codeUnits[dartx._get](i);
if ((dart.notNull(unit) & 192) != 128) {
expectedUnits = 0;
if (!dart.test(this[_allowMalformed])) {
@@ -32357,7 +32356,7 @@
i = dart.notNull(i) + 1;
}
} while (dart.notNull(expectedUnits) > 0);
- if (dart.notNull(value) <= dart.notNull(convert._Utf8Decoder._LIMITS[dartx.get](dart.notNull(extraUnits) - 1))) {
+ if (dart.notNull(value) <= dart.notNull(convert._Utf8Decoder._LIMITS[dartx._get](dart.notNull(extraUnits) - 1))) {
if (!dart.test(this[_allowMalformed])) {
dart.throw(new core.FormatException(dart.str`Overlong encoding of 0x${value[dartx.toRadixString](16)}`));
}
@@ -32383,7 +32382,7 @@
i = dart.notNull(i) + dart.notNull(oneBytes);
if (i == endIndex) break;
}
- let unit = codeUnits[dartx.get]((() => {
+ let unit = codeUnits[dartx._get]((() => {
let x = i;
i = dart.notNull(x) + 1;
return x;
@@ -32579,23 +32578,23 @@
return result;
}
dart.fn(parseMilliAndMicroseconds, StringToint$());
- let years = core.int.parse(match.get(1));
- let month = core.int.parse(match.get(2));
- let day = core.int.parse(match.get(3));
- let hour = parseIntOrZero(match.get(4));
- let minute = parseIntOrZero(match.get(5));
- let second = parseIntOrZero(match.get(6));
+ let years = core.int.parse(match._get(1));
+ let month = core.int.parse(match._get(2));
+ let day = core.int.parse(match._get(3));
+ let hour = parseIntOrZero(match._get(4));
+ let minute = parseIntOrZero(match._get(5));
+ let second = parseIntOrZero(match._get(6));
let addOneMillisecond = false;
- let milliAndMicroseconds = parseMilliAndMicroseconds(match.get(7));
+ let milliAndMicroseconds = parseMilliAndMicroseconds(match._get(7));
let millisecond = (dart.notNull(milliAndMicroseconds) / core.Duration.MICROSECONDS_PER_MILLISECOND)[dartx.truncate]();
let microsecond = dart.asInt(milliAndMicroseconds[dartx.remainder](core.Duration.MICROSECONDS_PER_MILLISECOND));
let isUtc = false;
- if (match.get(8) != null) {
+ if (match._get(8) != null) {
isUtc = true;
- if (match.get(9) != null) {
- let sign = match.get(9) == '-' ? -1 : 1;
- let hourDifference = core.int.parse(match.get(10));
- let minuteDifference = parseIntOrZero(match.get(11));
+ if (match._get(9) != null) {
+ let sign = match._get(9) == '-' ? -1 : 1;
+ let hourDifference = core.int.parse(match._get(10));
+ let minuteDifference = parseIntOrZero(match._get(11));
minuteDifference = dart.notNull(minuteDifference) + 60 * dart.notNull(hourDifference);
minute = dart.notNull(minute) - sign * dart.notNull(minuteDifference);
}
@@ -32965,7 +32964,7 @@
}
dart.fn(twoDigits, intToString());
if (dart.notNull(this.inMicroseconds) < 0) {
- return dart.str`-${this['unary-']()}`;
+ return dart.str`-${this._negate()}`;
}
let twoDigitMinutes = twoDigits(dart.asInt(this.inMinutes[dartx.remainder](core.Duration.MINUTES_PER_HOUR)));
let twoDigitSeconds = twoDigits(dart.asInt(this.inSeconds[dartx.remainder](core.Duration.SECONDS_PER_MINUTE)));
@@ -32978,7 +32977,7 @@
abs() {
return new core.Duration._microseconds(this[_duration][dartx.abs]());
}
- ['unary-']() {
+ _negate() {
return new core.Duration._microseconds(-dart.notNull(this[_duration]));
}
};
@@ -33010,7 +33009,7 @@
'>=': dart.definiteFunctionType(core.bool, [core.Duration]),
compareTo: dart.definiteFunctionType(core.int, [core.Duration]),
abs: dart.definiteFunctionType(core.Duration, []),
- 'unary-': dart.definiteFunctionType(core.Duration, [])
+ _negate: dart.definiteFunctionType(core.Duration, [])
}),
sfields: () => ({
MICROSECONDS_PER_MILLISECOND: core.int,
@@ -33340,7 +33339,7 @@
if (i > 0) {
sb.write(", ");
}
- sb.write(core.Error.safeToString(this[_arguments][dartx.get](i)));
+ sb.write(core.Error.safeToString(this[_arguments][dartx._get](i)));
}
}
if (this[_namedArguments] != null) {
@@ -33363,7 +33362,7 @@
if (i > 0) {
sb.write(", ");
}
- sb.write(this[_existingArgumentNames][dartx.get](i));
+ sb.write(this[_existingArgumentNames][dartx._get](i));
}
let formalParameters = sb.toString();
return "NoSuchMethodError: incorrect number of arguments passed to " + dart.str`method named '${this[_memberName]}'\n` + dart.str`Receiver: ${core.Error.safeToString(this[_receiver$])}\n` + dart.str`Tried calling: ${this[_memberName]}(${actualParameters})\n` + dart.str`Found: ${this[_memberName]}(${formalParameters})`;
@@ -33621,11 +33620,11 @@
toString() {
return dart.str`Expando:${this.name}`;
}
- get(object) {
+ _get(object) {
let values = _js_helper.Primitives.getProperty(object, core.Expando._EXPANDO_PROPERTY_NAME);
return T._check(values == null ? null : _js_helper.Primitives.getProperty(values, this[_getKey]()));
}
- set(object, value) {
+ _set(object, value) {
T._check(value);
let values = _js_helper.Primitives.getProperty(object, core.Expando._EXPANDO_PROPERTY_NAME);
if (values == null) {
@@ -33653,8 +33652,8 @@
constructors: () => ({new: dart.definiteFunctionType(core.Expando$(T), [], [core.String])}),
fields: () => ({name: core.String}),
methods: () => ({
- get: dart.definiteFunctionType(T, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.Object, T]),
+ _get: dart.definiteFunctionType(T, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.Object, T]),
[_getKey]: dart.definiteFunctionType(core.String, [])
}),
sfields: () => ({
@@ -33677,7 +33676,7 @@
static _toMangledNames(namedArguments) {
let result = dart.map({}, core.String, dart.dynamic);
namedArguments[dartx.forEach](dart.fn((symbol, value) => {
- result[dartx.set](core._symbolToString(symbol), value);
+ result[dartx._set](core._symbolToString(symbol), value);
}, SymbolAnddynamicTovoid()));
return result;
}
@@ -34155,7 +34154,7 @@
}
get currentAsString() {
if (this[_position$] == this[_nextPosition]) return null;
- if (dart.notNull(this[_position$]) + 1 == this[_nextPosition]) return this.string[dartx.get](this[_position$]);
+ if (dart.notNull(this[_position$]) + 1 == this[_nextPosition]) return this.string[dartx._get](this[_position$]);
return this.string[dartx.substring](this[_position$], this[_nextPosition]);
}
moveNext() {
@@ -34843,7 +34842,7 @@
if (this[_queryParameterLists] == null) {
let queryParameterLists = core.Uri._splitQueryStringAll(this.query);
for (let key of queryParameterLists[dartx.keys]) {
- queryParameterLists[dartx.set](key, ListOfString().unmodifiable(core.Iterable._check(queryParameterLists[dartx.get](key))));
+ queryParameterLists[dartx._set](key, ListOfString().unmodifiable(core.Iterable._check(queryParameterLists[dartx._get](key))));
}
this[_queryParameterLists] = MapOfString$ListOfString().unmodifiable(queryParameterLists);
}
@@ -34879,7 +34878,7 @@
return core.Uri._normalizeRegName(host, start, end);
}
static _isRegNameChar(char) {
- return dart.notNull(char) < 127 && (dart.notNull(core.Uri._regNameTable[dartx.get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
+ return dart.notNull(char) < 127 && (dart.notNull(core.Uri._regNameTable[dartx._get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
}
static _normalizeRegName(host, start, end) {
let buffer = null;
@@ -35074,9 +35073,9 @@
let codeUnits = null;
if (dart.notNull(char) < 128) {
codeUnits = ListOfint().new(3);
- codeUnits[dartx.set](0, core.Uri._PERCENT);
- codeUnits[dartx.set](1, core.Uri._hexDigits[dartx.codeUnitAt](char[dartx['>>']](4)));
- codeUnits[dartx.set](2, core.Uri._hexDigits[dartx.codeUnitAt](dart.notNull(char) & 15));
+ codeUnits[dartx._set](0, core.Uri._PERCENT);
+ codeUnits[dartx._set](1, core.Uri._hexDigits[dartx.codeUnitAt](char[dartx['>>']](4)));
+ codeUnits[dartx._set](2, core.Uri._hexDigits[dartx.codeUnitAt](dart.notNull(char) & 15));
} else {
let flag = 192;
let encodedBytes = 2;
@@ -35092,9 +35091,9 @@
let index = 0;
while (--encodedBytes >= 0) {
let byte = (char[dartx['>>']](6 * encodedBytes) & 63 | flag) >>> 0;
- codeUnits[dartx.set](index, core.Uri._PERCENT);
- codeUnits[dartx.set](index + 1, core.Uri._hexDigits[dartx.codeUnitAt](byte[dartx['>>']](4)));
- codeUnits[dartx.set](index + 2, core.Uri._hexDigits[dartx.codeUnitAt](byte & 15));
+ codeUnits[dartx._set](index, core.Uri._PERCENT);
+ codeUnits[dartx._set](index + 1, core.Uri._hexDigits[dartx.codeUnitAt](byte[dartx['>>']](4)));
+ codeUnits[dartx._set](index + 2, core.Uri._hexDigits[dartx.codeUnitAt](byte & 15));
index = index + 3;
flag = 128;
}
@@ -35107,7 +35106,7 @@
let index = start;
while (dart.notNull(index) < dart.notNull(end)) {
let char = component[dartx.codeUnitAt](index);
- if (dart.notNull(char) < 127 && (dart.notNull(charTable[dartx.get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0) {
+ if (dart.notNull(char) < 127 && (dart.notNull(charTable[dartx._get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0) {
index = dart.notNull(index) + 1;
} else {
let replacement = null;
@@ -35155,10 +35154,10 @@
return dart.toString(buffer);
}
static _isSchemeCharacter(ch) {
- return dart.notNull(ch) < 128 && (dart.notNull(core.Uri._schemeTable[dartx.get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
+ return dart.notNull(ch) < 128 && (dart.notNull(core.Uri._schemeTable[dartx._get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
}
static _isGeneralDelimiter(ch) {
- return dart.notNull(ch) <= core.Uri._RIGHT_BRACKET && (dart.notNull(core.Uri._genDelimitersTable[dartx.get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
+ return dart.notNull(ch) <= core.Uri._RIGHT_BRACKET && (dart.notNull(core.Uri._genDelimitersTable[dartx._get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
}
get isAbsolute() {
return this.scheme != "" && this.fragment == "";
@@ -35235,7 +35234,7 @@
output[dartx.add](segment);
}
}
- if (dart.test(output[dartx.isEmpty]) || output[dartx.length] == 1 && dart.test(output[dartx.get](0)[dartx.isEmpty])) {
+ if (dart.test(output[dartx.isEmpty]) || output[dartx.length] == 1 && dart.test(output[dartx._get](0)[dartx.isEmpty])) {
return "./";
}
if (appendSlash || output[dartx.last] == '..') output[dartx.add]("");
@@ -35365,8 +35364,8 @@
[_toWindowsFilePath]() {
let hasDriveLetter = false;
let segments = this.pathSegments;
- if (dart.notNull(segments[dartx.length]) > 0 && segments[dartx.get](0)[dartx.length] == 2 && segments[dartx.get](0)[dartx.codeUnitAt](1) == core.Uri._COLON) {
- core.Uri._checkWindowsDriveLetter(segments[dartx.get](0)[dartx.codeUnitAt](0), false);
+ if (dart.notNull(segments[dartx.length]) > 0 && segments[dartx._get](0)[dartx.length] == 2 && segments[dartx._get](0)[dartx.codeUnitAt](1) == core.Uri._COLON) {
+ core.Uri._checkWindowsDriveLetter(segments[dartx._get](0)[dartx.codeUnitAt](0), false);
core.Uri._checkWindowsPathReservedCharacters(segments, false, 1);
hasDriveLetter = true;
} else {
@@ -35463,12 +35462,12 @@
let index = element[dartx.indexOf]("=");
if (index == -1) {
if (element != "") {
- map[dartx.set](core.Uri.decodeQueryComponent(element, {encoding: encoding}), "");
+ map[dartx._set](core.Uri.decodeQueryComponent(element, {encoding: encoding}), "");
}
} else if (index != 0) {
let key = element[dartx.substring](0, index);
let value = element[dartx.substring](dart.notNull(index) + 1);
- map[dartx.set](core.Uri.decodeQueryComponent(key, {encoding: encoding}), core.Uri.decodeQueryComponent(value, {encoding: encoding}));
+ map[dartx._set](core.Uri.decodeQueryComponent(key, {encoding: encoding}), core.Uri.decodeQueryComponent(value, {encoding: encoding}));
}
return map;
}, MapOfString$StringAndStringToMapOfString$String()));
@@ -35586,8 +35585,8 @@
} catch (e) {
try {
let last = core.Uri.parseIPv4Address(host[dartx.substring](partStart, end));
- parts[dartx.add]((dart.notNull(last[dartx.get](0)) << 8 | dart.notNull(last[dartx.get](1))) >>> 0);
- parts[dartx.add]((dart.notNull(last[dartx.get](2)) << 8 | dart.notNull(last[dartx.get](3))) >>> 0);
+ parts[dartx.add]((dart.notNull(last[dartx._get](0)) << 8 | dart.notNull(last[dartx._get](1))) >>> 0);
+ parts[dartx.add]((dart.notNull(last[dartx._get](2)) << 8 | dart.notNull(last[dartx._get](3))) >>> 0);
} catch (e) {
error('invalid end of IPv6 address.', partStart);
}
@@ -35604,17 +35603,17 @@
}
let bytes = typed_data.Uint8List.new(16);
for (let i = 0, index = 0; i < dart.notNull(parts[dartx.length]); i++) {
- let value = parts[dartx.get](i);
+ let value = parts[dartx._get](i);
if (value == -1) {
let wildCardLength = 9 - dart.notNull(parts[dartx.length]);
for (let j = 0; j < wildCardLength; j++) {
- bytes[dartx.set](index, 0);
- bytes[dartx.set](index + 1, 0);
+ bytes[dartx._set](index, 0);
+ bytes[dartx._set](index + 1, 0);
index = index + 2;
}
} else {
- bytes[dartx.set](index, value[dartx['>>']](8));
- bytes[dartx.set](index + 1, dart.notNull(value) & 255);
+ bytes[dartx._set](index, value[dartx['>>']](8));
+ bytes[dartx._set](index + 1, dart.notNull(value) & 255);
index = index + 2;
}
}
@@ -35627,16 +35626,16 @@
let result = new core.StringBuffer();
let bytes = encoding.encode(text);
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byte = bytes[dartx.get](i);
- if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx.get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
+ let byte = bytes[dartx._get](i);
+ if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx._get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
result.writeCharCode(byte);
} else if (dart.test(spaceToPlus) && byte == core.Uri._SPACE) {
result.write('+');
} else {
let hexDigits = '0123456789ABCDEF';
result.write('%');
- result.write(hexDigits[dartx.get](dart.notNull(byte) >> 4 & 15));
- result.write(hexDigits[dartx.get](dart.notNull(byte) & 15));
+ result.write(hexDigits[dartx._get](dart.notNull(byte) >> 4 & 15));
+ result.write(hexDigits[dartx._get](dart.notNull(byte) & 15));
}
}
return result.toString();
@@ -35705,7 +35704,7 @@
return core.Uri._LOWER_CASE_A <= lowerCase && lowerCase <= core.Uri._LOWER_CASE_Z;
}
static _isUnreservedChar(char) {
- return dart.notNull(char) < 127 && (dart.notNull(core.Uri._unreservedTable[dartx.get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
+ return dart.notNull(char) < 127 && (dart.notNull(core.Uri._unreservedTable[dartx._get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
}
};
dart.defineNamedConstructor(core.Uri, '_internal');
@@ -35923,7 +35922,7 @@
let indices = JSArrayOfint().of([core.UriData._noScheme]);
let charsetName = null;
let encodingName = null;
- if (parameters != null) charsetName = parameters[dartx.get]("charset");
+ if (parameters != null) charsetName = parameters[dartx._get]("charset");
if (encoding == null) {
if (charsetName != null) {
encoding = convert.Encoding.getByName(charsetName);
@@ -36039,7 +36038,7 @@
if (this[_uriCache] != null) return this[_uriCache];
let path = this[_text];
let query = null;
- let colonIndex = this[_separatorIndices][dartx.get](0);
+ let colonIndex = this[_separatorIndices][dartx._get](0);
let queryIndex = this[_text][dartx.indexOf]('?', dart.notNull(colonIndex) + 1);
let end = null;
if (dart.notNull(queryIndex) >= 0) {
@@ -36051,8 +36050,8 @@
return this[_uriCache];
}
get mimeType() {
- let start = dart.notNull(this[_separatorIndices][dartx.get](0)) + 1;
- let end = this[_separatorIndices][dartx.get](1);
+ let start = dart.notNull(this[_separatorIndices][dartx._get](0)) + 1;
+ let end = this[_separatorIndices][dartx._get](1);
if (start == end) return "text/plain";
return core.Uri._uriDecode(this[_text], start, end, convert.UTF8, false);
}
@@ -36063,10 +36062,10 @@
parameterEnd = parameterEnd - 1;
}
for (let i = parameterStart; i < parameterEnd; i = i + 2) {
- let keyStart = dart.notNull(this[_separatorIndices][dartx.get](i)) + 1;
- let keyEnd = this[_separatorIndices][dartx.get](i + 1);
+ let keyStart = dart.notNull(this[_separatorIndices][dartx._get](i)) + 1;
+ let keyEnd = this[_separatorIndices][dartx._get](i + 1);
if (keyEnd == keyStart + 7 && dart.test(this[_text][dartx.startsWith]("charset", keyStart))) {
- return core.Uri._uriDecode(this[_text], dart.notNull(keyEnd) + 1, this[_separatorIndices][dartx.get](i + 2), convert.UTF8, false);
+ return core.Uri._uriDecode(this[_text], dart.notNull(keyEnd) + 1, this[_separatorIndices][dartx._get](i + 2), convert.UTF8, false);
}
}
return "US-ASCII";
@@ -36101,14 +36100,14 @@
for (let i = start; i < dart.notNull(text[dartx.length]); i++) {
let codeUnit = text[dartx.codeUnitAt](i);
if (codeUnit != percent) {
- result[dartx.set](index++, codeUnit);
+ result[dartx._set](index++, codeUnit);
} else {
if (i + 2 < dart.notNull(text[dartx.length])) {
let digit1 = core.Uri._parseHexDigit(text[dartx.codeUnitAt](i + 1));
let digit2 = core.Uri._parseHexDigit(text[dartx.codeUnitAt](i + 2));
if (dart.notNull(digit1) >= 0 && dart.notNull(digit2) >= 0) {
let byte = dart.notNull(digit1) * 16 + dart.notNull(digit2);
- result[dartx.set](index++, byte);
+ result[dartx._set](index++, byte);
i = i + 2;
continue;
}
@@ -36139,12 +36138,12 @@
get parameters() {
let result = dart.map({}, core.String, core.String);
for (let i = 3; i < dart.notNull(this[_separatorIndices][dartx.length]); i = i + 2) {
- let start = dart.notNull(this[_separatorIndices][dartx.get](i - 2)) + 1;
- let equals = this[_separatorIndices][dartx.get](i - 1);
- let end = this[_separatorIndices][dartx.get](i);
+ let start = dart.notNull(this[_separatorIndices][dartx._get](i - 2)) + 1;
+ let equals = this[_separatorIndices][dartx._get](i - 1);
+ let end = this[_separatorIndices][dartx._get](i);
let key = core.Uri._uriDecode(this[_text], start, equals, convert.UTF8, false);
let value = core.Uri._uriDecode(this[_text], dart.notNull(equals) + 1, end, convert.UTF8, false);
- result[dartx.set](key, value);
+ result[dartx._set](key, value);
}
return result;
}
@@ -36201,9 +36200,9 @@
static _uriEncodeBytes(canonicalTable, bytes, buffer) {
let byteOr = 0;
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
byteOr = (dart.notNull(byteOr) | dart.notNull(byte)) >>> 0;
- if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx.get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
+ if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx._get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
buffer.writeCharCode(byte);
} else {
buffer.writeCharCode(core.Uri._PERCENT);
@@ -36213,7 +36212,7 @@
}
if ((dart.notNull(byteOr) & ~255) != 0) {
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) {
dart.throw(new core.ArgumentError.value(byte, "non-byte value"));
}
@@ -36221,7 +36220,7 @@
}
}
toString() {
- return this[_separatorIndices][dartx.get](0) == core.UriData._noScheme ? dart.str`data:${this[_text]}` : this[_text];
+ return this[_separatorIndices][dartx._get](0) == core.UriData._noScheme ? dart.str`data:${this[_text]}` : this[_text];
}
};
dart.defineNamedConstructor(core.UriData, '_');
@@ -36294,7 +36293,7 @@
static spawn(entryPoint, message, opts) {
let paused = opts && 'paused' in opts ? opts.paused : false;
try {
- return _isolate_helper.IsolateNatives.spawnFunction(entryPoint, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx.get](1)), {pauseCapability: isolate.Capability._check(msg[dartx.get](2)), terminateCapability: isolate.Capability._check(msg[dartx.get](3))}), ListToIsolate()));
+ return _isolate_helper.IsolateNatives.spawnFunction(entryPoint, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx._get](1)), {pauseCapability: isolate.Capability._check(msg[dartx._get](2)), terminateCapability: isolate.Capability._check(msg[dartx._get](3))}), ListToIsolate()));
} catch (e) {
let st = dart.stackTrace(e);
return FutureOfIsolate().error(e, st);
@@ -36308,14 +36307,14 @@
try {
if (core.List.is(args)) {
for (let i = 0; i < dart.notNull(args[dartx.length]); i++) {
- if (!(typeof args[dartx.get](i) == 'string')) {
+ if (!(typeof args[dartx._get](i) == 'string')) {
dart.throw(new core.ArgumentError(dart.str`Args must be a list of Strings ${args}`));
}
}
} else if (args != null) {
dart.throw(new core.ArgumentError(dart.str`Args must be a list of Strings ${args}`));
}
- return _isolate_helper.IsolateNatives.spawnUri(uri, args, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx.get](1)), {pauseCapability: isolate.Capability._check(msg[dartx.get](2)), terminateCapability: isolate.Capability._check(msg[dartx.get](3))}), ListToIsolate()));
+ return _isolate_helper.IsolateNatives.spawnUri(uri, args, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx._get](1)), {pauseCapability: isolate.Capability._check(msg[dartx._get](2)), terminateCapability: isolate.Capability._check(msg[dartx._get](3))}), ListToIsolate()));
} catch (e) {
let st = dart.stackTrace(e);
return FutureOfIsolate().error(e, st);
@@ -36330,34 +36329,34 @@
}
[_pause](resumeCapability) {
let message = core.List.new(3);
- message[dartx.set](0, "pause");
- message[dartx.set](1, this.pauseCapability);
- message[dartx.set](2, resumeCapability);
+ message[dartx._set](0, "pause");
+ message[dartx._set](1, this.pauseCapability);
+ message[dartx._set](2, resumeCapability);
this.controlPort.send(message);
}
resume(resumeCapability) {
let message = core.List.new(2);
- message[dartx.set](0, "resume");
- message[dartx.set](1, resumeCapability);
+ message[dartx._set](0, "resume");
+ message[dartx._set](1, resumeCapability);
this.controlPort.send(message);
}
addOnExitListener(responsePort) {
let message = core.List.new(2);
- message[dartx.set](0, "add-ondone");
- message[dartx.set](1, responsePort);
+ message[dartx._set](0, "add-ondone");
+ message[dartx._set](1, responsePort);
this.controlPort.send(message);
}
removeOnExitListener(responsePort) {
let message = core.List.new(2);
- message[dartx.set](0, "remove-ondone");
- message[dartx.set](1, responsePort);
+ message[dartx._set](0, "remove-ondone");
+ message[dartx._set](1, responsePort);
this.controlPort.send(message);
}
setErrorsFatal(errorsAreFatal) {
let message = core.List.new(3);
- message[dartx.set](0, "set-errors-fatal");
- message[dartx.set](1, this.terminateCapability);
- message[dartx.set](2, errorsAreFatal);
+ message[dartx._set](0, "set-errors-fatal");
+ message[dartx._set](1, this.terminateCapability);
+ message[dartx._set](2, errorsAreFatal);
this.controlPort.send(message);
}
kill(priority) {
@@ -36367,21 +36366,21 @@
ping(responsePort, pingType) {
if (pingType === void 0) pingType = isolate.Isolate.IMMEDIATE;
let message = core.List.new(3);
- message[dartx.set](0, "ping");
- message[dartx.set](1, responsePort);
- message[dartx.set](2, pingType);
+ message[dartx._set](0, "ping");
+ message[dartx._set](1, responsePort);
+ message[dartx._set](2, pingType);
this.controlPort.send(message);
}
addErrorListener(port) {
let message = core.List.new(2);
- message[dartx.set](0, "getErrors");
- message[dartx.set](1, port);
+ message[dartx._set](0, "getErrors");
+ message[dartx._set](1, port);
this.controlPort.send(message);
}
removeErrorListener(port) {
let message = core.List.new(2);
- message[dartx.set](0, "stopErrors");
- message[dartx.set](1, port);
+ message[dartx._set](0, "stopErrors");
+ message[dartx._set](1, port);
this.controlPort.send(message);
}
get errors() {
@@ -36572,18 +36571,18 @@
let _convertedObjects = collection.HashMap.identity();
function _convert(o) {
if (dart.test(_convertedObjects.containsKey(o))) {
- return _convertedObjects.get(o);
+ return _convertedObjects._get(o);
}
if (core.Map.is(o)) {
let convertedMap = {};
- _convertedObjects.set(o, convertedMap);
+ _convertedObjects._set(o, convertedMap);
for (let key of o[dartx.keys]) {
- convertedMap[key] = _convert(o[dartx.get](key));
+ convertedMap[key] = _convert(o[dartx._get](key));
}
return convertedMap;
} else if (core.Iterable.is(o)) {
let convertedList = [];
- _convertedObjects.set(o, convertedList);
+ _convertedObjects._set(o, convertedList);
convertedList[dartx.addAll](o[dartx.map](dart.dynamic)(_convert));
return convertedList;
} else {
@@ -36593,13 +36592,13 @@
dart.fn(_convert, dynamicTodynamic$());
return _convert(data);
}
- get(property) {
+ _get(property) {
if (!(typeof property == 'string') && !(typeof property == 'number')) {
dart.throw(new core.ArgumentError("property is not a String or num"));
}
return js._convertToDart(this[_jsObject][property]);
}
- set(property, value) {
+ _set(property, value) {
if (!(typeof property == 'string') && !(typeof property == 'number')) {
dart.throw(new core.ArgumentError("property is not a String or num"));
}
@@ -36658,8 +36657,8 @@
}),
fields: () => ({[_jsObject]: dart.dynamic}),
methods: () => ({
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
- set: dart.definiteFunctionType(dart.dynamic, [core.Object, dart.dynamic]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _set: dart.definiteFunctionType(dart.dynamic, [core.Object, dart.dynamic]),
hasProperty: dart.definiteFunctionType(core.bool, [dart.dynamic]),
deleteProperty: dart.definiteFunctionType(dart.void, [dart.dynamic]),
instanceof: dart.definiteFunctionType(core.bool, [js.JsFunction]),
@@ -36733,18 +36732,18 @@
dart.throw(new core.RangeError.range(end, start, length));
}
}
- get(index) {
+ _get(index) {
if (typeof index == 'number' && index == index[dartx.toInt]()) {
this[_checkIndex](dart.asInt(index));
}
- return E.as(super.get(index));
+ return E.as(super._get(index));
}
- set(index, value) {
+ _set(index, value) {
E._check(value);
if (typeof index == 'number' && index == index[dartx.toInt]()) {
this[_checkIndex](dart.asInt(index));
}
- super.set(index, value);
+ super._set(index, value);
return value;
}
get length() {
@@ -36755,7 +36754,7 @@
dart.throw(new core.StateError('Bad JsArray length'));
}
set length(length) {
- super.set('length', length);
+ super._set('length', length);
}
add(value) {
E._check(value);
@@ -36813,8 +36812,8 @@
methods: () => ({
[_checkIndex]: dart.definiteFunctionType(dart.dynamic, [core.int]),
[_checkInsertIndex]: dart.definiteFunctionType(dart.dynamic, [core.int]),
- get: dart.definiteFunctionType(E, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.Object, E]),
+ _get: dart.definiteFunctionType(E, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.Object, E]),
add: dart.definiteFunctionType(dart.void, [E]),
addAll: dart.definiteFunctionType(dart.void, [IterableOfE()]),
insert: dart.definiteFunctionType(dart.void, [core.int, E]),
@@ -36827,8 +36826,8 @@
names: ['_checkRange']
});
dart.defineExtensionMembers(JsArray, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'add',
'addAll',
'insert',
@@ -36935,7 +36934,7 @@
set _interopCaptureThisExpando(_) {}
});
js.allowInteropCaptureThis = function(f) {
- let ret = js._interopCaptureThisExpando.get(f);
+ let ret = js._interopCaptureThisExpando._get(f);
if (ret == null) {
ret = function() {
let args = [this];
@@ -36944,7 +36943,7 @@
}
return f(...args);
};
- js._interopCaptureThisExpando.set(f, ret);
+ js._interopCaptureThisExpando._set(f, ret);
}
return ret;
};
@@ -36960,18 +36959,18 @@
let _convertedObjects = collection.HashMap.identity();
function _convert(o) {
if (dart.test(_convertedObjects.containsKey(o))) {
- return _convertedObjects.get(o);
+ return _convertedObjects._get(o);
}
if (core.Map.is(o)) {
let convertedMap = {};
- _convertedObjects.set(o, convertedMap);
+ _convertedObjects._set(o, convertedMap);
for (let key of o[dartx.keys]) {
- convertedMap[key] = _convert(o[dartx.get](key));
+ convertedMap[key] = _convert(o[dartx._get](key));
}
return convertedMap;
} else if (core.Iterable.is(o)) {
let convertedList = [];
- _convertedObjects.set(o, convertedList);
+ _convertedObjects._set(o, convertedList);
convertedList[dartx.addAll](o[dartx.map](dart.dynamic)(_convert));
return convertedList;
} else {
@@ -37582,11 +37581,35 @@
'height'
]);
class Rectangle extends math._RectangleBase$(T) {
+ get left() {
+ return this[left$];
+ }
+ set left(value) {
+ super.left = value;
+ }
+ get top() {
+ return this[top$];
+ }
+ set top(value) {
+ super.top = value;
+ }
+ get width() {
+ return this[width$];
+ }
+ set width(value) {
+ super.width = value;
+ }
+ get height() {
+ return this[height$];
+ }
+ set height(value) {
+ super.height = value;
+ }
new(left, top, width, height) {
- this[dartx.left] = left;
- this[dartx.top] = top;
- this[dartx.width] = dart.notNull(width) < 0 ? -dart.notNull(width) * 0 : width;
- this[dartx.height] = dart.notNull(height) < 0 ? -dart.notNull(height) * 0 : height;
+ this[left$] = left;
+ this[top$] = top;
+ this[width$] = dart.notNull(width) < 0 ? -dart.notNull(width) * 0 : width;
+ this[height$] = dart.notNull(height) < 0 ? -dart.notNull(height) * 0 : height;
super.new();
}
static fromPoints(a, b) {
@@ -37597,6 +37620,10 @@
return new (RectangleOfT())(left, top, width, height);
}
}
+ const left$ = Symbol(Rectangle.name + "." + 'left'.toString());
+ const top$ = Symbol(Rectangle.name + "." + 'top'.toString());
+ const width$ = Symbol(Rectangle.name + "." + 'width'.toString());
+ const height$ = Symbol(Rectangle.name + "." + 'height'.toString());
dart.setSignature(Rectangle, {
constructors: () => ({
new: dart.definiteFunctionType(math.Rectangle$(T), [T, T, T, T]),
@@ -37620,9 +37647,21 @@
let RectangleOfT = () => (RectangleOfT = dart.constFn(math.Rectangle$(T)))();
let PointOfT = () => (PointOfT = dart.constFn(math.Point$(T)))();
class MutableRectangle extends math._RectangleBase$(T) {
+ get left() {
+ return this[left$];
+ }
+ set left(value) {
+ this[left$] = value;
+ }
+ get top() {
+ return this[top$];
+ }
+ set top(value) {
+ this[top$] = value;
+ }
new(left, top, width, height) {
- this.left = left;
- this.top = top;
+ this[left$] = left;
+ this[top$] = top;
this[_width] = dart.notNull(width) < 0 ? math._clampToZero(T)(width) : width;
this[_height] = dart.notNull(height) < 0 ? math._clampToZero(T)(height) : height;
super.new();
@@ -37651,6 +37690,8 @@
this[_height] = height;
}
}
+ const left$ = Symbol(MutableRectangle.name + "." + 'left'.toString());
+ const top$ = Symbol(MutableRectangle.name + "." + 'top'.toString());
MutableRectangle[dart.implements] = () => [RectangleOfT()];
dart.setSignature(MutableRectangle, {
constructors: () => ({
@@ -38229,7 +38270,7 @@
if (dart.test(html_common.isJavaScriptDate(object))) return true;
if (core.List.is(object)) {
for (let i = 0; i < dart.notNull(object[dartx.length]); i++) {
- if (dart.test(containsDate(object[dartx.get](i)))) return true;
+ if (dart.test(containsDate(object[dartx._get](i)))) return true;
}
}
return false;
@@ -38448,10 +38489,10 @@
let autoIncrement = opts && 'autoIncrement' in opts ? opts.autoIncrement : null;
let options = dart.map();
if (keyPath != null) {
- options[dartx.set]('keyPath', keyPath);
+ options[dartx._set]('keyPath', keyPath);
}
if (autoIncrement != null) {
- options[dartx.set]('autoIncrement', autoIncrement);
+ options[dartx._set]('autoIncrement', autoIncrement);
}
return this[_createObjectStore](name, options);
}
@@ -39043,10 +39084,10 @@
let multiEntry = opts && 'multiEntry' in opts ? opts.multiEntry : null;
let options = dart.map();
if (unique != null) {
- options[dartx.set]('unique', unique);
+ options[dartx._set]('unique', unique);
}
if (multiEntry != null) {
- options[dartx.set]('multiEntry', multiEntry);
+ options[dartx._set]('multiEntry', multiEntry);
}
return this[_createIndex](name, keyPath, options);
}
@@ -40225,7 +40266,7 @@
let attributes = this[dartx.attributes];
attributes[dartx.clear]();
for (let key of value[dartx.keys]) {
- attributes[dartx.set](key, value[dartx.get](key));
+ attributes[dartx._set](key, value[dartx._get](key));
}
}
get [dartx.children]() {
@@ -40265,7 +40306,7 @@
let data = this[dartx.dataset];
data[dartx.clear]();
for (let key of value[dartx.keys]) {
- data[dartx.set](key, value[dartx.get](key));
+ data[dartx._set](key, value[dartx._get](key));
}
}
[dartx.getNamespacedAttributes](namespace) {
@@ -40414,7 +40455,7 @@
}
case 'afterbegin':
{
- let first = dart.notNull(this[dartx.nodes][dartx.length]) > 0 ? this[dartx.nodes][dartx.get](0) : null;
+ let first = dart.notNull(this[dartx.nodes][dartx.length]) > 0 ? this[dartx.nodes][dartx._get](0) : null;
this[dartx.insertBefore](node, first);
break;
}
@@ -53164,7 +53205,7 @@
'clear',
'item',
'remove',
- 'get',
+ '_get',
'length'
]);
html$.DataTransferItemList = class DataTransferItemList extends _interceptors.Interceptor {
@@ -53192,7 +53233,7 @@
[dartx.remove](index) {
return this.remove(index);
}
- [dartx.get](index) {
+ [dartx._get](index) {
return this[index];
}
};
@@ -53206,7 +53247,7 @@
[dartx.clear]: dart.definiteFunctionType(dart.void, []),
[dartx.item]: dart.definiteFunctionType(html$.DataTransferItem, [core.int]),
[dartx.remove]: dart.definiteFunctionType(dart.void, [core.int]),
- [dartx.get]: dart.definiteFunctionType(html$.DataTransferItem, [core.int])
+ [dartx._get]: dart.definiteFunctionType(html$.DataTransferItem, [core.int])
})
});
dart.registerExtension(dart.global.DataTransferItemList, html$.DataTransferItemList);
@@ -56037,8 +56078,8 @@
html$.ImmutableListMixin = ImmutableListMixin();
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -56053,11 +56094,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.item](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -56086,7 +56127,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__getter__](index) {
return this.__getter__(index);
@@ -56106,8 +56147,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.String, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
[dartx.elementAt]: dart.definiteFunctionType(core.String, [core.int]),
[__getter__]: dart.definiteFunctionType(core.String, [core.int]),
[dartx.item]: dart.definiteFunctionType(core.String, [core.int])
@@ -56148,11 +56189,11 @@
get length() {
return this[_childElements][dartx.length];
}
- get(index) {
- return html$.Element._check(this[_childElements][dartx.get](index));
+ _get(index) {
+ return html$.Element._check(this[_childElements][dartx._get](index));
}
- set(index, value) {
- this[_element$][_replaceChild](value, this[_childElements][dartx.get](index));
+ _set(index, value) {
+ this[_element$][_replaceChild](value, this[_childElements][dartx._get](index));
return value;
}
set length(newLength) {
@@ -56225,7 +56266,7 @@
if (index == this.length) {
this[_element$][dartx.append](element);
} else {
- this[_element$][dartx.insertBefore](element, this.get(index));
+ this[_element$][dartx.insertBefore](element, this._get(index));
}
}
setAll(index, iterable) {
@@ -56235,7 +56276,7 @@
this[_element$][_clearChildren]();
}
removeAt(index) {
- let result = this.get(index);
+ let result = this._get(index);
if (result != null) {
this[_element$][_removeChild](result);
}
@@ -56285,8 +56326,8 @@
}),
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- get: dart.definiteFunctionType(html$.Element, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
+ _get: dart.definiteFunctionType(html$.Element, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
add: dart.definiteFunctionType(html$.Element, [html$.Element]),
addAll: dart.definiteFunctionType(dart.void, [IterableOfElement()]),
sort: dart.definiteFunctionType(dart.void, [], [ElementAndElementToint()]),
@@ -56304,8 +56345,8 @@
});
dart.defineExtensionMembers(html$._ChildrenElementList, [
'contains',
- 'get',
- 'set',
+ '_get',
+ '_set',
'add',
'addAll',
'sort',
@@ -56347,10 +56388,10 @@
get length() {
return this[_nodeList][dartx.length];
}
- get(index) {
- return html$._downcast(html$.Node, E)(this[_nodeList][dartx.get](index));
+ _get(index) {
+ return html$._downcast(html$.Node, E)(this[_nodeList][dartx._get](index));
}
- set(index, value) {
+ _set(index, value) {
E._check(value);
dart.throw(new core.UnsupportedError('Cannot modify list'));
return value;
@@ -56699,14 +56740,14 @@
classes: dart.definiteFunctionType(dart.void, [IterableOfString()])
}),
methods: () => ({
- get: dart.definiteFunctionType(E, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _get: dart.definiteFunctionType(E, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
sort: dart.definiteFunctionType(dart.void, [], [ComparatorOfE()])
})
});
dart.defineExtensionMembers(_FrozenElementList, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sort',
'shuffle',
'length',
@@ -57012,23 +57053,23 @@
new(ptr) {
this[_ptr] = ptr;
}
- get(type) {
+ _get(type) {
return new (_EventStreamOfEvent())(this[_ptr], type, false);
}
};
dart.setSignature(html$.Events, {
constructors: () => ({new: dart.definiteFunctionType(html$.Events, [html$.EventTarget])}),
fields: () => ({[_ptr]: html$.EventTarget}),
- methods: () => ({get: dart.definiteFunctionType(async.Stream, [core.String])})
+ methods: () => ({_get: dart.definiteFunctionType(async.Stream, [core.String])})
});
html$.ElementEvents = class ElementEvents extends html$.Events {
new(ptr) {
super.new(ptr);
}
- get(type) {
+ _get(type) {
if (dart.test(html$.ElementEvents.webkitEvents[dartx.keys][dartx.contains](type[dartx.toLowerCase]()))) {
if (dart.test(html_common.Device.isWebKit)) {
- return new (_ElementEventStreamImplOfEvent())(this[_ptr], html$.ElementEvents.webkitEvents[dartx.get](type[dartx.toLowerCase]()), false);
+ return new (_ElementEventStreamImplOfEvent())(this[_ptr], html$.ElementEvents.webkitEvents[dartx._get](type[dartx.toLowerCase]()), false);
}
}
return new (_ElementEventStreamImplOfEvent())(this[_ptr], type, false);
@@ -57411,8 +57452,8 @@
dart.registerExtension(dart.global.FileError, html$.FileError);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -57427,11 +57468,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -57460,7 +57501,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -57477,8 +57518,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.File, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.File]),
+ [dartx._get]: dart.definiteFunctionType(html$.File, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.File]),
[dartx.elementAt]: dart.definiteFunctionType(html$.File, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.File, [core.int])
})
@@ -58411,13 +58452,13 @@
let maximumAge = opts && 'maximumAge' in opts ? opts.maximumAge : null;
let options = dart.map();
if (enableHighAccuracy != null) {
- options[dartx.set]('enableHighAccuracy', enableHighAccuracy);
+ options[dartx._set]('enableHighAccuracy', enableHighAccuracy);
}
if (timeout != null) {
- options[dartx.set]('timeout', timeout.inMilliseconds);
+ options[dartx._set]('timeout', timeout.inMilliseconds);
}
if (maximumAge != null) {
- options[dartx.set]('maximumAge', maximumAge.inMilliseconds);
+ options[dartx._set]('maximumAge', maximumAge.inMilliseconds);
}
let completer = CompleterOfGeoposition().new();
try {
@@ -58439,13 +58480,13 @@
let maximumAge = opts && 'maximumAge' in opts ? opts.maximumAge : null;
let options = dart.map();
if (enableHighAccuracy != null) {
- options[dartx.set]('enableHighAccuracy', enableHighAccuracy);
+ options[dartx._set]('enableHighAccuracy', enableHighAccuracy);
}
if (timeout != null) {
- options[dartx.set]('timeout', timeout.inMilliseconds);
+ options[dartx._set]('timeout', timeout.inMilliseconds);
}
if (maximumAge != null) {
- options[dartx.set]('maximumAge', maximumAge.inMilliseconds);
+ options[dartx._set]('maximumAge', maximumAge.inMilliseconds);
}
let watchId = null;
let controller = null;
@@ -59485,8 +59526,8 @@
dart.registerExtension(dart.global.HMDVRDevice, html$.HmdvrDevice);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -59502,11 +59543,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -59535,7 +59576,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -59555,8 +59596,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Node, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
+ [dartx._get]: dart.definiteFunctionType(html$.Node, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Node, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.Node, [core.int]),
[dartx.namedItem]: dart.definiteFunctionType(core.Object, [core.String])
@@ -59990,9 +60031,9 @@
let key = header[dartx.substring](0, splitIdx)[dartx.toLowerCase]();
let value = header[dartx.substring](dart.notNull(splitIdx) + 2);
if (dart.test(headers[dartx.containsKey](key))) {
- headers[dartx.set](key, dart.str`${headers[dartx.get](key)}, ${value}`);
+ headers[dartx._set](key, dart.str`${headers[dartx._get](key)}, ${value}`);
} else {
- headers[dartx.set](key, value);
+ headers[dartx._set](key, value);
}
}
return headers;
@@ -61048,14 +61089,56 @@
]);
html$.InputElementBase = class InputElementBase extends core.Object {
new() {
- this[dartx.autofocus] = null;
- this[dartx.disabled] = null;
- this[dartx.incremental] = null;
- this[dartx.indeterminate] = null;
- this[dartx.name] = null;
- this[dartx.value] = null;
+ this[autofocus] = null;
+ this[disabled] = null;
+ this[incremental] = null;
+ this[indeterminate] = null;
+ this[name] = null;
+ this[value$] = null;
+ }
+ get autofocus() {
+ return this[autofocus];
+ }
+ set autofocus(value) {
+ this[autofocus] = value;
+ }
+ get disabled() {
+ return this[disabled];
+ }
+ set disabled(value) {
+ this[disabled] = value;
+ }
+ get incremental() {
+ return this[incremental];
+ }
+ set incremental(value) {
+ this[incremental] = value;
+ }
+ get indeterminate() {
+ return this[indeterminate];
+ }
+ set indeterminate(value) {
+ this[indeterminate] = value;
+ }
+ get name() {
+ return this[name];
+ }
+ set name(value) {
+ this[name] = value;
+ }
+ get value() {
+ return this[value$];
+ }
+ set value(value) {
+ this[value$] = value;
}
};
+ const autofocus = Symbol(html$.InputElementBase.name + "." + 'autofocus'.toString());
+ const disabled = Symbol(html$.InputElementBase.name + "." + 'disabled'.toString());
+ const incremental = Symbol(html$.InputElementBase.name + "." + 'incremental'.toString());
+ const indeterminate = Symbol(html$.InputElementBase.name + "." + 'indeterminate'.toString());
+ const name = Symbol(html$.InputElementBase.name + "." + 'name'.toString());
+ const value$ = Symbol(html$.InputElementBase.name + "." + 'value'.toString());
html$.InputElementBase[dart.implements] = () => [html$.Element];
dart.setSignature(html$.InputElementBase, {
fields: () => ({
@@ -61104,18 +61187,88 @@
]);
html$.TextInputElementBase = class TextInputElementBase extends core.Object {
new() {
- this[dartx.autocomplete] = null;
- this[dartx.maxLength] = null;
- this[dartx.pattern] = null;
- this[dartx.placeholder] = null;
- this[dartx.readOnly] = null;
- this[dartx.required] = null;
- this[dartx.size] = null;
- this[dartx.selectionDirection] = null;
- this[dartx.selectionEnd] = null;
- this[dartx.selectionStart] = null;
+ this[autocomplete] = null;
+ this[maxLength] = null;
+ this[pattern] = null;
+ this[placeholder] = null;
+ this[readOnly] = null;
+ this[required] = null;
+ this[size] = null;
+ this[selectionDirection] = null;
+ this[selectionEnd] = null;
+ this[selectionStart] = null;
+ }
+ get autocomplete() {
+ return this[autocomplete];
+ }
+ set autocomplete(value) {
+ this[autocomplete] = value;
+ }
+ get maxLength() {
+ return this[maxLength];
+ }
+ set maxLength(value) {
+ this[maxLength] = value;
+ }
+ get pattern() {
+ return this[pattern];
+ }
+ set pattern(value) {
+ this[pattern] = value;
+ }
+ get placeholder() {
+ return this[placeholder];
+ }
+ set placeholder(value) {
+ this[placeholder] = value;
+ }
+ get readOnly() {
+ return this[readOnly];
+ }
+ set readOnly(value) {
+ this[readOnly] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
+ get size() {
+ return this[size];
+ }
+ set size(value) {
+ this[size] = value;
+ }
+ get selectionDirection() {
+ return this[selectionDirection];
+ }
+ set selectionDirection(value) {
+ this[selectionDirection] = value;
+ }
+ get selectionEnd() {
+ return this[selectionEnd];
+ }
+ set selectionEnd(value) {
+ this[selectionEnd] = value;
+ }
+ get selectionStart() {
+ return this[selectionStart];
+ }
+ set selectionStart(value) {
+ this[selectionStart] = value;
}
};
+ const autocomplete = Symbol(html$.TextInputElementBase.name + "." + 'autocomplete'.toString());
+ const maxLength = Symbol(html$.TextInputElementBase.name + "." + 'maxLength'.toString());
+ const pattern = Symbol(html$.TextInputElementBase.name + "." + 'pattern'.toString());
+ const placeholder = Symbol(html$.TextInputElementBase.name + "." + 'placeholder'.toString());
+ const readOnly = Symbol(html$.TextInputElementBase.name + "." + 'readOnly'.toString());
+ const required = Symbol(html$.TextInputElementBase.name + "." + 'required'.toString());
+ const size = Symbol(html$.TextInputElementBase.name + "." + 'size'.toString());
+ const selectionDirection = Symbol(html$.TextInputElementBase.name + "." + 'selectionDirection'.toString());
+ const selectionEnd = Symbol(html$.TextInputElementBase.name + "." + 'selectionEnd'.toString());
+ const selectionStart = Symbol(html$.TextInputElementBase.name + "." + 'selectionStart'.toString());
html$.TextInputElementBase[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.TextInputElementBase, {
fields: () => ({
@@ -61160,10 +61313,17 @@
static new() {
return html$.InputElement.new({type: 'search'});
}
+ get dirName() {
+ return this[dirName];
+ }
+ set dirName(value) {
+ this[dirName] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'search'})[dartx.type] == 'search';
}
};
+ const dirName = Symbol(html$.SearchInputElement.name + "." + 'dirName'.toString());
html$.SearchInputElement[dart.implements] = () => [html$.TextInputElementBase];
dart.setSignature(html$.SearchInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.SearchInputElement, [])}),
@@ -61178,7 +61338,14 @@
static new() {
return html$.InputElement.new({type: 'text'});
}
+ get dirName() {
+ return this[dirName$];
+ }
+ set dirName(value) {
+ this[dirName$] = value;
+ }
};
+ const dirName$ = Symbol(html$.TextInputElement.name + "." + 'dirName'.toString());
html$.TextInputElement[dart.implements] = () => [html$.TextInputElementBase];
dart.setSignature(html$.TextInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.TextInputElement, [])}),
@@ -61226,10 +61393,73 @@
static new() {
return html$.InputElement.new({type: 'email'});
}
+ get autocomplete() {
+ return this[autocomplete$];
+ }
+ set autocomplete(value) {
+ this[autocomplete$] = value;
+ }
+ get autofocus() {
+ return this[autofocus$];
+ }
+ set autofocus(value) {
+ this[autofocus$] = value;
+ }
+ get maxLength() {
+ return this[maxLength$];
+ }
+ set maxLength(value) {
+ this[maxLength$] = value;
+ }
+ get multiple() {
+ return this[multiple];
+ }
+ set multiple(value) {
+ this[multiple] = value;
+ }
+ get pattern() {
+ return this[pattern$];
+ }
+ set pattern(value) {
+ this[pattern$] = value;
+ }
+ get placeholder() {
+ return this[placeholder$];
+ }
+ set placeholder(value) {
+ this[placeholder$] = value;
+ }
+ get readOnly() {
+ return this[readOnly$];
+ }
+ set readOnly(value) {
+ this[readOnly$] = value;
+ }
+ get required() {
+ return this[required$];
+ }
+ set required(value) {
+ this[required$] = value;
+ }
+ get size() {
+ return this[size$];
+ }
+ set size(value) {
+ this[size$] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'email'})[dartx.type] == 'email';
}
};
+ const autocomplete$ = Symbol(html$.EmailInputElement.name + "." + 'autocomplete'.toString());
+ const autofocus$ = Symbol(html$.EmailInputElement.name + "." + 'autofocus'.toString());
+ const maxLength$ = Symbol(html$.EmailInputElement.name + "." + 'maxLength'.toString());
+ const multiple = Symbol(html$.EmailInputElement.name + "." + 'multiple'.toString());
+ const pattern$ = Symbol(html$.EmailInputElement.name + "." + 'pattern'.toString());
+ const placeholder$ = Symbol(html$.EmailInputElement.name + "." + 'placeholder'.toString());
+ const readOnly$ = Symbol(html$.EmailInputElement.name + "." + 'readOnly'.toString());
+ const required$ = Symbol(html$.EmailInputElement.name + "." + 'required'.toString());
+ const size$ = Symbol(html$.EmailInputElement.name + "." + 'size'.toString());
html$.EmailInputElement[dart.implements] = () => [html$.TextInputElementBase];
dart.setSignature(html$.EmailInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.EmailInputElement, [])}),
@@ -61283,12 +61513,40 @@
]);
html$.RangeInputElementBase = class RangeInputElementBase extends core.Object {
new() {
- this[dartx.max] = null;
- this[dartx.min] = null;
- this[dartx.step] = null;
- this[dartx.valueAsNumber] = null;
+ this[max] = null;
+ this[min] = null;
+ this[step] = null;
+ this[valueAsNumber] = null;
+ }
+ get max() {
+ return this[max];
+ }
+ set max(value) {
+ this[max] = value;
+ }
+ get min() {
+ return this[min];
+ }
+ set min(value) {
+ this[min] = value;
+ }
+ get step() {
+ return this[step];
+ }
+ set step(value) {
+ this[step] = value;
+ }
+ get valueAsNumber() {
+ return this[valueAsNumber];
+ }
+ set valueAsNumber(value) {
+ this[valueAsNumber] = value;
}
};
+ const max = Symbol(html$.RangeInputElementBase.name + "." + 'max'.toString());
+ const min = Symbol(html$.RangeInputElementBase.name + "." + 'min'.toString());
+ const step = Symbol(html$.RangeInputElementBase.name + "." + 'step'.toString());
+ const valueAsNumber = Symbol(html$.RangeInputElementBase.name + "." + 'valueAsNumber'.toString());
html$.RangeInputElementBase[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.RangeInputElementBase, {
fields: () => ({
@@ -61317,10 +61575,31 @@
static new() {
return html$.InputElement.new({type: 'date'});
}
+ get valueAsDate() {
+ return this[valueAsDate];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate] = value;
+ }
+ get readOnly() {
+ return this[readOnly$0];
+ }
+ set readOnly(value) {
+ this[readOnly$0] = value;
+ }
+ get required() {
+ return this[required$0];
+ }
+ set required(value) {
+ this[required$0] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'date'})[dartx.type] == 'date';
}
};
+ const valueAsDate = Symbol(html$.DateInputElement.name + "." + 'valueAsDate'.toString());
+ const readOnly$0 = Symbol(html$.DateInputElement.name + "." + 'readOnly'.toString());
+ const required$0 = Symbol(html$.DateInputElement.name + "." + 'required'.toString());
html$.DateInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.DateInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.DateInputElement, [])}),
@@ -61348,10 +61627,31 @@
static new() {
return html$.InputElement.new({type: 'month'});
}
+ get valueAsDate() {
+ return this[valueAsDate$];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate$] = value;
+ }
+ get readOnly() {
+ return this[readOnly$1];
+ }
+ set readOnly(value) {
+ this[readOnly$1] = value;
+ }
+ get required() {
+ return this[required$1];
+ }
+ set required(value) {
+ this[required$1] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'month'})[dartx.type] == 'month';
}
};
+ const valueAsDate$ = Symbol(html$.MonthInputElement.name + "." + 'valueAsDate'.toString());
+ const readOnly$1 = Symbol(html$.MonthInputElement.name + "." + 'readOnly'.toString());
+ const required$1 = Symbol(html$.MonthInputElement.name + "." + 'required'.toString());
html$.MonthInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.MonthInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.MonthInputElement, [])}),
@@ -61379,10 +61679,31 @@
static new() {
return html$.InputElement.new({type: 'week'});
}
+ get valueAsDate() {
+ return this[valueAsDate$0];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate$0] = value;
+ }
+ get readOnly() {
+ return this[readOnly$2];
+ }
+ set readOnly(value) {
+ this[readOnly$2] = value;
+ }
+ get required() {
+ return this[required$2];
+ }
+ set required(value) {
+ this[required$2] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'week'})[dartx.type] == 'week';
}
};
+ const valueAsDate$0 = Symbol(html$.WeekInputElement.name + "." + 'valueAsDate'.toString());
+ const readOnly$2 = Symbol(html$.WeekInputElement.name + "." + 'readOnly'.toString());
+ const required$2 = Symbol(html$.WeekInputElement.name + "." + 'required'.toString());
html$.WeekInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.WeekInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.WeekInputElement, [])}),
@@ -61410,10 +61731,31 @@
static new() {
return html$.InputElement.new({type: 'time'});
}
+ get valueAsDate() {
+ return this[valueAsDate$1];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate$1] = value;
+ }
+ get readOnly() {
+ return this[readOnly$3];
+ }
+ set readOnly(value) {
+ this[readOnly$3] = value;
+ }
+ get required() {
+ return this[required$3];
+ }
+ set required(value) {
+ this[required$3] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'time'})[dartx.type] == 'time';
}
};
+ const valueAsDate$1 = Symbol(html$.TimeInputElement.name + "." + 'valueAsDate'.toString());
+ const readOnly$3 = Symbol(html$.TimeInputElement.name + "." + 'readOnly'.toString());
+ const required$3 = Symbol(html$.TimeInputElement.name + "." + 'required'.toString());
html$.TimeInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.TimeInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.TimeInputElement, [])}),
@@ -61440,10 +61782,24 @@
static new() {
return html$.InputElement.new({type: 'datetime-local'});
}
+ get readOnly() {
+ return this[readOnly$4];
+ }
+ set readOnly(value) {
+ this[readOnly$4] = value;
+ }
+ get required() {
+ return this[required$4];
+ }
+ set required(value) {
+ this[required$4] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'datetime-local'})[dartx.type] == 'datetime-local';
}
};
+ const readOnly$4 = Symbol(html$.LocalDateTimeInputElement.name + "." + 'readOnly'.toString());
+ const required$4 = Symbol(html$.LocalDateTimeInputElement.name + "." + 'required'.toString());
html$.LocalDateTimeInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.LocalDateTimeInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.LocalDateTimeInputElement, [])}),
@@ -61463,10 +61819,31 @@
static new() {
return html$.InputElement.new({type: 'number'});
}
+ get placeholder() {
+ return this[placeholder$0];
+ }
+ set placeholder(value) {
+ this[placeholder$0] = value;
+ }
+ get readOnly() {
+ return this[readOnly$5];
+ }
+ set readOnly(value) {
+ this[readOnly$5] = value;
+ }
+ get required() {
+ return this[required$5];
+ }
+ set required(value) {
+ this[required$5] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'number'})[dartx.type] == 'number';
}
};
+ const placeholder$0 = Symbol(html$.NumberInputElement.name + "." + 'placeholder'.toString());
+ const readOnly$5 = Symbol(html$.NumberInputElement.name + "." + 'readOnly'.toString());
+ const required$5 = Symbol(html$.NumberInputElement.name + "." + 'required'.toString());
html$.NumberInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.NumberInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.NumberInputElement, [])}),
@@ -61506,7 +61883,21 @@
static new() {
return html$.InputElement.new({type: 'checkbox'});
}
+ get checked() {
+ return this[checked];
+ }
+ set checked(value) {
+ this[checked] = value;
+ }
+ get required() {
+ return this[required$6];
+ }
+ set required(value) {
+ this[required$6] = value;
+ }
};
+ const checked = Symbol(html$.CheckboxInputElement.name + "." + 'checked'.toString());
+ const required$6 = Symbol(html$.CheckboxInputElement.name + "." + 'required'.toString());
html$.CheckboxInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.CheckboxInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.CheckboxInputElement, [])}),
@@ -61524,7 +61915,21 @@
static new() {
return html$.InputElement.new({type: 'radio'});
}
+ get checked() {
+ return this[checked$];
+ }
+ set checked(value) {
+ this[checked$] = value;
+ }
+ get required() {
+ return this[required$7];
+ }
+ set required(value) {
+ this[required$7] = value;
+ }
};
+ const checked$ = Symbol(html$.RadioButtonInputElement.name + "." + 'checked'.toString());
+ const required$7 = Symbol(html$.RadioButtonInputElement.name + "." + 'required'.toString());
html$.RadioButtonInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.RadioButtonInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.RadioButtonInputElement, [])}),
@@ -61544,7 +61949,35 @@
static new() {
return html$.InputElement.new({type: 'file'});
}
+ get accept() {
+ return this[accept];
+ }
+ set accept(value) {
+ this[accept] = value;
+ }
+ get multiple() {
+ return this[multiple$];
+ }
+ set multiple(value) {
+ this[multiple$] = value;
+ }
+ get required() {
+ return this[required$8];
+ }
+ set required(value) {
+ this[required$8] = value;
+ }
+ get files() {
+ return this[files];
+ }
+ set files(value) {
+ this[files] = value;
+ }
};
+ const accept = Symbol(html$.FileUploadInputElement.name + "." + 'accept'.toString());
+ const multiple$ = Symbol(html$.FileUploadInputElement.name + "." + 'multiple'.toString());
+ const required$8 = Symbol(html$.FileUploadInputElement.name + "." + 'required'.toString());
+ const files = Symbol(html$.FileUploadInputElement.name + "." + 'files'.toString());
html$.FileUploadInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.FileUploadInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.FileUploadInputElement, [])}),
@@ -61576,7 +62009,42 @@
static new() {
return html$.InputElement.new({type: 'submit'});
}
+ get formAction() {
+ return this[formAction];
+ }
+ set formAction(value) {
+ this[formAction] = value;
+ }
+ get formEnctype() {
+ return this[formEnctype];
+ }
+ set formEnctype(value) {
+ this[formEnctype] = value;
+ }
+ get formMethod() {
+ return this[formMethod];
+ }
+ set formMethod(value) {
+ this[formMethod] = value;
+ }
+ get formNoValidate() {
+ return this[formNoValidate];
+ }
+ set formNoValidate(value) {
+ this[formNoValidate] = value;
+ }
+ get formTarget() {
+ return this[formTarget];
+ }
+ set formTarget(value) {
+ this[formTarget] = value;
+ }
};
+ const formAction = Symbol(html$.SubmitButtonInputElement.name + "." + 'formAction'.toString());
+ const formEnctype = Symbol(html$.SubmitButtonInputElement.name + "." + 'formEnctype'.toString());
+ const formMethod = Symbol(html$.SubmitButtonInputElement.name + "." + 'formMethod'.toString());
+ const formNoValidate = Symbol(html$.SubmitButtonInputElement.name + "." + 'formNoValidate'.toString());
+ const formTarget = Symbol(html$.SubmitButtonInputElement.name + "." + 'formTarget'.toString());
html$.SubmitButtonInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.SubmitButtonInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.SubmitButtonInputElement, [])}),
@@ -61615,7 +62083,70 @@
static new() {
return html$.InputElement.new({type: 'image'});
}
+ get alt() {
+ return this[alt];
+ }
+ set alt(value) {
+ this[alt] = value;
+ }
+ get formAction() {
+ return this[formAction$];
+ }
+ set formAction(value) {
+ this[formAction$] = value;
+ }
+ get formEnctype() {
+ return this[formEnctype$];
+ }
+ set formEnctype(value) {
+ this[formEnctype$] = value;
+ }
+ get formMethod() {
+ return this[formMethod$];
+ }
+ set formMethod(value) {
+ this[formMethod$] = value;
+ }
+ get formNoValidate() {
+ return this[formNoValidate$];
+ }
+ set formNoValidate(value) {
+ this[formNoValidate$] = value;
+ }
+ get formTarget() {
+ return this[formTarget$];
+ }
+ set formTarget(value) {
+ this[formTarget$] = value;
+ }
+ get height() {
+ return this[height];
+ }
+ set height(value) {
+ this[height] = value;
+ }
+ get src() {
+ return this[src];
+ }
+ set src(value) {
+ this[src] = value;
+ }
+ get width() {
+ return this[width];
+ }
+ set width(value) {
+ this[width] = value;
+ }
};
+ const alt = Symbol(html$.ImageButtonInputElement.name + "." + 'alt'.toString());
+ const formAction$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formAction'.toString());
+ const formEnctype$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formEnctype'.toString());
+ const formMethod$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formMethod'.toString());
+ const formNoValidate$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formNoValidate'.toString());
+ const formTarget$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formTarget'.toString());
+ const height = Symbol(html$.ImageButtonInputElement.name + "." + 'height'.toString());
+ const src = Symbol(html$.ImageButtonInputElement.name + "." + 'src'.toString());
+ const width = Symbol(html$.ImageButtonInputElement.name + "." + 'width'.toString());
html$.ImageButtonInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.ImageButtonInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.ImageButtonInputElement, [])}),
@@ -64189,8 +64720,8 @@
dart.registerExtension(dart.global.MimeType, html$.MimeType);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -64206,11 +64737,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -64239,7 +64770,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -64259,8 +64790,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.MimeType, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.MimeType]),
+ [dartx._get]: dart.definiteFunctionType(html$.MimeType, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.MimeType]),
[dartx.elementAt]: dart.definiteFunctionType(html$.MimeType, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.MimeType, [core.int]),
[dartx.namedItem]: dart.definiteFunctionType(html$.MimeType, [core.String])
@@ -64939,7 +65470,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get hardwareConcurrency() {
+ return this[hardwareConcurrency];
+ }
+ set hardwareConcurrency(value) {
+ super.hardwareConcurrency = value;
+ }
};
+ const hardwareConcurrency = Symbol(html$.NavigatorCpu.name + "." + 'hardwareConcurrency'.toString());
dart.setSignature(html$.NavigatorCpu, {
constructors: () => ({_: dart.definiteFunctionType(html$.NavigatorCpu, [])}),
fields: () => ({hardwareConcurrency: core.int})
@@ -64958,7 +65496,56 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get appCodeName() {
+ return this[appCodeName];
+ }
+ set appCodeName(value) {
+ super.appCodeName = value;
+ }
+ get appName() {
+ return this[appName];
+ }
+ set appName(value) {
+ super.appName = value;
+ }
+ get appVersion() {
+ return this[appVersion];
+ }
+ set appVersion(value) {
+ super.appVersion = value;
+ }
+ get dartEnabled() {
+ return this[dartEnabled];
+ }
+ set dartEnabled(value) {
+ super.dartEnabled = value;
+ }
+ get platform() {
+ return this[platform];
+ }
+ set platform(value) {
+ super.platform = value;
+ }
+ get product() {
+ return this[product];
+ }
+ set product(value) {
+ super.product = value;
+ }
+ get userAgent() {
+ return this[userAgent];
+ }
+ set userAgent(value) {
+ super.userAgent = value;
+ }
};
+ const appCodeName = Symbol(html$.NavigatorID.name + "." + 'appCodeName'.toString());
+ const appName = Symbol(html$.NavigatorID.name + "." + 'appName'.toString());
+ const appVersion = Symbol(html$.NavigatorID.name + "." + 'appVersion'.toString());
+ const dartEnabled = Symbol(html$.NavigatorID.name + "." + 'dartEnabled'.toString());
+ const platform = Symbol(html$.NavigatorID.name + "." + 'platform'.toString());
+ const product = Symbol(html$.NavigatorID.name + "." + 'product'.toString());
+ const userAgent = Symbol(html$.NavigatorID.name + "." + 'userAgent'.toString());
dart.setSignature(html$.NavigatorID, {
constructors: () => ({_: dart.definiteFunctionType(html$.NavigatorID, [])}),
fields: () => ({
@@ -64988,7 +65575,21 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get language() {
+ return this[language];
+ }
+ set language(value) {
+ super.language = value;
+ }
+ get languages() {
+ return this[languages];
+ }
+ set languages(value) {
+ super.languages = value;
+ }
};
+ const language = Symbol(html$.NavigatorLanguage.name + "." + 'language'.toString());
+ const languages = Symbol(html$.NavigatorLanguage.name + "." + 'languages'.toString());
dart.setSignature(html$.NavigatorLanguage, {
constructors: () => ({_: dart.definiteFunctionType(html$.NavigatorLanguage, [])}),
fields: () => ({
@@ -65004,7 +65605,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get onLine() {
+ return this[onLine];
+ }
+ set onLine(value) {
+ super.onLine = value;
+ }
};
+ const onLine = Symbol(html$.NavigatorOnLine.name + "." + 'onLine'.toString());
dart.setSignature(html$.NavigatorOnLine, {
constructors: () => ({_: dart.definiteFunctionType(html$.NavigatorOnLine, [])}),
fields: () => ({onLine: core.bool})
@@ -65121,14 +65729,14 @@
if (index == this.length) {
this[_this][dartx.append](node);
} else {
- this[_this][dartx.insertBefore](node, this.get(index));
+ this[_this][dartx.insertBefore](node, this._get(index));
}
}
insertAll(index, iterable) {
if (index == this.length) {
this.addAll(iterable);
} else {
- let item = this.get(index);
+ let item = this._get(index);
this[_this][dartx.insertAllBefore](iterable, item);
}
}
@@ -65143,7 +65751,7 @@
return result;
}
removeAt(index) {
- let result = this.get(index);
+ let result = this._get(index);
if (result != null) {
this[_this][_removeChild](result);
}
@@ -65175,8 +65783,8 @@
clear() {
this[_this][_clearChildren]();
}
- set(index, value) {
- this[_this][_replaceChild](value, this.get(index));
+ _set(index, value) {
+ this[_this][_replaceChild](value, this._get(index));
return value;
}
get iterator() {
@@ -65204,8 +65812,8 @@
set length(value) {
dart.throw(new core.UnsupportedError("Cannot set length on immutable List."));
}
- get(index) {
- return this[_this][dartx.childNodes][dartx.get](index);
+ _get(index) {
+ return this[_this][dartx.childNodes][dartx._get](index);
}
get rawList() {
return this[_this][dartx.childNodes];
@@ -65236,11 +65844,11 @@
[_filter$]: dart.definiteFunctionType(dart.void, [NodeTobool(), core.bool]),
removeWhere: dart.definiteFunctionType(dart.void, [NodeTobool()]),
retainWhere: dart.definiteFunctionType(dart.void, [NodeTobool()]),
- set: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
sort: dart.definiteFunctionType(dart.void, [], [ComparatorOfNode()]),
setRange: dart.definiteFunctionType(dart.void, [core.int, core.int, IterableOfNode()], [core.int]),
fillRange: dart.definiteFunctionType(dart.void, [core.int, core.int], [html$.Node]),
- get: dart.definiteFunctionType(html$.Node, [core.int])
+ _get: dart.definiteFunctionType(html$.Node, [core.int])
})
});
dart.defineExtensionMembers(html$._ChildNodeListLazy, [
@@ -65255,12 +65863,12 @@
'removeWhere',
'retainWhere',
'clear',
- 'set',
+ '_set',
'sort',
'shuffle',
'setRange',
'fillRange',
- 'get',
+ '_get',
'first',
'last',
'single',
@@ -65359,8 +65967,8 @@
dart.registerExtension(dart.global.NodeIterator, html$.NodeIterator);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -65374,11 +65982,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -65407,7 +66015,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[_item](index) {
return this.item(index);
@@ -65424,8 +66032,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Node, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
+ [dartx._get]: dart.definiteFunctionType(html$.Node, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Node, [core.int]),
[_item]: dart.definiteFunctionType(html$.Node, [core.int])
})
@@ -65496,11 +66104,11 @@
let tag = opts && 'tag' in opts ? opts.tag : null;
let icon = opts && 'icon' in opts ? opts.icon : null;
let parsedOptions = dart.map();
- if (dir != null) parsedOptions[dartx.set]('dir', dir);
- if (body != null) parsedOptions[dartx.set]('body', body);
- if (lang != null) parsedOptions[dartx.set]('lang', lang);
- if (tag != null) parsedOptions[dartx.set]('tag', tag);
- if (icon != null) parsedOptions[dartx.set]('icon', icon);
+ if (dir != null) parsedOptions[dartx._set]('dir', dir);
+ if (body != null) parsedOptions[dartx._set]('body', body);
+ if (lang != null) parsedOptions[dartx._set]('lang', lang);
+ if (tag != null) parsedOptions[dartx._set]('tag', tag);
+ if (icon != null) parsedOptions[dartx._set]('icon', icon);
return html$.Notification._factoryNotification(title, parsedOptions);
}
static _() {
@@ -67041,8 +67649,8 @@
dart.registerExtension(dart.global.Plugin, html$.Plugin);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -67059,11 +67667,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -67092,7 +67700,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -67115,8 +67723,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Plugin, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Plugin]),
+ [dartx._get]: dart.definiteFunctionType(html$.Plugin, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Plugin]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Plugin, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.Plugin, [core.int]),
[dartx.namedItem]: dart.definiteFunctionType(html$.Plugin, [core.String]),
@@ -69563,7 +70171,7 @@
let options = this[dartx.options][dartx.where](dart.fn(o => o[dartx.selected], OptionElementTobool()))[dartx.toList]();
return new (UnmodifiableListViewOfOptionElement())(options);
} else {
- return JSArrayOfOptionElement().of([this[dartx.options][dartx.get](this[dartx.selectedIndex])]);
+ return JSArrayOfOptionElement().of([this[dartx.options][dartx._get](this[dartx.selectedIndex])]);
}
}
};
@@ -70531,8 +71139,8 @@
dart.registerExtension(dart.global.SourceBuffer, html$.SourceBuffer);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -70547,11 +71155,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -70580,7 +71188,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -70597,8 +71205,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.SourceBuffer, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.SourceBuffer]),
+ [dartx._get]: dart.definiteFunctionType(html$.SourceBuffer, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.SourceBuffer]),
[dartx.elementAt]: dart.definiteFunctionType(html$.SourceBuffer, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.SourceBuffer, [core.int])
})
@@ -70768,8 +71376,8 @@
dart.registerExtension(dart.global.SpeechGrammar, html$.SpeechGrammar);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -70792,11 +71400,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -70825,7 +71433,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.addFromString](string, weight) {
return this.addFromString(string, weight);
@@ -70851,8 +71459,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.SpeechGrammar, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.SpeechGrammar]),
+ [dartx._get]: dart.definiteFunctionType(html$.SpeechGrammar, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.SpeechGrammar]),
[dartx.elementAt]: dart.definiteFunctionType(html$.SpeechGrammar, [core.int]),
[dartx.addFromString]: dart.definiteFunctionType(dart.void, [core.String], [core.num]),
[dartx.addFromUri]: dart.definiteFunctionType(dart.void, [core.String], [core.num]),
@@ -71544,8 +72152,8 @@
'addAll',
'containsValue',
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -71559,7 +72167,7 @@
html$.Storage = class Storage extends _interceptors.Interceptor {
[dartx.addAll](other) {
other[dartx.forEach](dart.fn((k, v) => {
- this[dartx.set](k, v);
+ this[dartx._set](k, v);
}, StringAndStringTovoid$()));
}
[dartx.containsValue](value) {
@@ -71568,19 +72176,19 @@
[dartx.containsKey](key) {
return this[_getItem](core.String._check(key)) != null;
}
- [dartx.get](key) {
+ [dartx._get](key) {
return this[_getItem](core.String._check(key));
}
- [dartx.set](key, value) {
+ [dartx._set](key, value) {
this[_setItem](key, value);
return value;
}
[dartx.putIfAbsent](key, ifAbsent) {
- if (!dart.test(this[dartx.containsKey](key))) this[dartx.set](key, ifAbsent());
- return this[dartx.get](key);
+ if (!dart.test(this[dartx.containsKey](key))) this[dartx._set](key, ifAbsent());
+ return this[dartx._get](key);
}
[dartx.remove](key) {
- let value = this[dartx.get](key);
+ let value = this[dartx._get](key);
this[_removeItem](core.String._check(key));
return value;
}
@@ -71591,7 +72199,7 @@
for (let i = 0; true; i++) {
let key = this[_key](i);
if (key == null) return;
- f(key, this[dartx.get](key));
+ f(key, this[dartx._get](key));
}
}
get [dartx.keys]() {
@@ -71659,8 +72267,8 @@
[dartx.addAll]: dart.definiteFunctionType(dart.void, [MapOfString$String()]),
[dartx.containsValue]: dart.definiteFunctionType(core.bool, [core.Object]),
[dartx.containsKey]: dart.definiteFunctionType(core.bool, [core.Object]),
- [dartx.get]: dart.definiteFunctionType(core.String, [core.Object]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.Object]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.String, core.String]),
[dartx.putIfAbsent]: dart.definiteFunctionType(core.String, [core.String, VoidToString()]),
[dartx.remove]: dart.definiteFunctionType(core.String, [core.Object]),
[dartx.clear]: dart.definiteFunctionType(dart.void, []),
@@ -72989,8 +73597,8 @@
dart.registerExtension(dart.global.TextTrackCue, html$.TextTrackCue);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -73006,11 +73614,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -73039,7 +73647,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.getCueById](id) {
return this.getCueById(id);
@@ -73059,8 +73667,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.TextTrackCue, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.TextTrackCue]),
+ [dartx._get]: dart.definiteFunctionType(html$.TextTrackCue, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.TextTrackCue]),
[dartx.elementAt]: dart.definiteFunctionType(html$.TextTrackCue, [core.int]),
[dartx.getCueById]: dart.definiteFunctionType(html$.TextTrackCue, [core.String]),
[dartx.item]: dart.definiteFunctionType(html$.TextTrackCue, [core.int])
@@ -73069,8 +73677,8 @@
dart.registerExtension(dart.global.TextTrackCueList, html$.TextTrackCueList);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -73088,11 +73696,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -73121,7 +73729,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.getTrackById](id) {
return this.getTrackById(id);
@@ -73149,8 +73757,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.TextTrack, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.TextTrack]),
+ [dartx._get]: dart.definiteFunctionType(html$.TextTrack, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.TextTrack]),
[dartx.elementAt]: dart.definiteFunctionType(html$.TextTrack, [core.int]),
[dartx.getTrackById]: dart.definiteFunctionType(html$.TextTrack, [core.String]),
[dartx.item]: dart.definiteFunctionType(html$.TextTrack, [core.int])
@@ -73435,8 +74043,8 @@
dart.registerExtension(dart.global.TouchEvent, html$.TouchEvent);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -73457,11 +74065,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -73490,7 +74098,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -73510,8 +74118,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Touch, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Touch]),
+ [dartx._get]: dart.definiteFunctionType(html$.Touch, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Touch]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Touch, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.Touch, [core.int])
}),
@@ -74063,7 +74671,84 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get hash() {
+ return this[hash];
+ }
+ set hash(value) {
+ this[hash] = value;
+ }
+ get host() {
+ return this[host];
+ }
+ set host(value) {
+ this[host] = value;
+ }
+ get hostname() {
+ return this[hostname];
+ }
+ set hostname(value) {
+ this[hostname] = value;
+ }
+ get href() {
+ return this[href];
+ }
+ set href(value) {
+ this[href] = value;
+ }
+ get origin() {
+ return this[origin];
+ }
+ set origin(value) {
+ super.origin = value;
+ }
+ get password() {
+ return this[password];
+ }
+ set password(value) {
+ this[password] = value;
+ }
+ get pathname() {
+ return this[pathname];
+ }
+ set pathname(value) {
+ this[pathname] = value;
+ }
+ get port() {
+ return this[port];
+ }
+ set port(value) {
+ this[port] = value;
+ }
+ get protocol() {
+ return this[protocol];
+ }
+ set protocol(value) {
+ this[protocol] = value;
+ }
+ get search() {
+ return this[search];
+ }
+ set search(value) {
+ this[search] = value;
+ }
+ get username() {
+ return this[username];
+ }
+ set username(value) {
+ this[username] = value;
+ }
};
+ const hash = Symbol(html$.UrlUtils.name + "." + 'hash'.toString());
+ const host = Symbol(html$.UrlUtils.name + "." + 'host'.toString());
+ const hostname = Symbol(html$.UrlUtils.name + "." + 'hostname'.toString());
+ const href = Symbol(html$.UrlUtils.name + "." + 'href'.toString());
+ const origin = Symbol(html$.UrlUtils.name + "." + 'origin'.toString());
+ const password = Symbol(html$.UrlUtils.name + "." + 'password'.toString());
+ const pathname = Symbol(html$.UrlUtils.name + "." + 'pathname'.toString());
+ const port = Symbol(html$.UrlUtils.name + "." + 'port'.toString());
+ const protocol = Symbol(html$.UrlUtils.name + "." + 'protocol'.toString());
+ const search = Symbol(html$.UrlUtils.name + "." + 'search'.toString());
+ const username = Symbol(html$.UrlUtils.name + "." + 'username'.toString());
dart.setSignature(html$.UrlUtils, {
constructors: () => ({_: dart.definiteFunctionType(html$.UrlUtils, [])}),
fields: () => ({
@@ -74118,7 +74803,70 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get hash() {
+ return this[hash$];
+ }
+ set hash(value) {
+ super.hash = value;
+ }
+ get host() {
+ return this[host$];
+ }
+ set host(value) {
+ super.host = value;
+ }
+ get hostname() {
+ return this[hostname$];
+ }
+ set hostname(value) {
+ super.hostname = value;
+ }
+ get href() {
+ return this[href$];
+ }
+ set href(value) {
+ super.href = value;
+ }
+ get origin() {
+ return this[origin$];
+ }
+ set origin(value) {
+ super.origin = value;
+ }
+ get pathname() {
+ return this[pathname$];
+ }
+ set pathname(value) {
+ super.pathname = value;
+ }
+ get port() {
+ return this[port$];
+ }
+ set port(value) {
+ super.port = value;
+ }
+ get protocol() {
+ return this[protocol$];
+ }
+ set protocol(value) {
+ super.protocol = value;
+ }
+ get search() {
+ return this[search$];
+ }
+ set search(value) {
+ super.search = value;
+ }
};
+ const hash$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'hash'.toString());
+ const host$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'host'.toString());
+ const hostname$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'hostname'.toString());
+ const href$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'href'.toString());
+ const origin$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'origin'.toString());
+ const pathname$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'pathname'.toString());
+ const port$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'port'.toString());
+ const protocol$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'protocol'.toString());
+ const search$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'search'.toString());
dart.setSignature(html$.UrlUtilsReadOnly, {
constructors: () => ({_: dart.definiteFunctionType(html$.UrlUtilsReadOnly, [])}),
fields: () => ({
@@ -77185,8 +77933,8 @@
});
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77201,11 +77949,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.item](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77234,7 +77982,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__getter__](index) {
return this.__getter__(index);
@@ -77254,8 +78002,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, RectangleOfnum()]),
+ [dartx._get]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, RectangleOfnum()]),
[dartx.elementAt]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
[__getter__]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
[dartx.item]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int])
@@ -77265,8 +78013,8 @@
dart.registerExtension(dart.global.DOMRectList, html$._ClientRectList);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77281,11 +78029,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77314,7 +78062,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -77331,8 +78079,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.CssRule, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.CssRule]),
+ [dartx._get]: dart.definiteFunctionType(html$.CssRule, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.CssRule]),
[dartx.elementAt]: dart.definiteFunctionType(html$.CssRule, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.CssRule, [core.int])
})
@@ -77518,8 +78266,8 @@
dart.registerExtension(dart.global.FileWriterSync, html$._FileWriterSync);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77534,11 +78282,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77567,7 +78315,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -77584,8 +78332,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Gamepad, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Gamepad]),
+ [dartx._get]: dart.definiteFunctionType(html$.Gamepad, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Gamepad]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Gamepad, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.Gamepad, [core.int])
})
@@ -77703,8 +78451,8 @@
dart.registerExtension(dart.global.HTMLMarqueeElement, html$._HTMLMarqueeElement);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77725,11 +78473,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77758,7 +78506,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.getNamedItem](name) {
return this.getNamedItem(name);
@@ -77793,8 +78541,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Node, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
+ [dartx._get]: dart.definiteFunctionType(html$.Node, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Node, [core.int]),
[dartx.getNamedItem]: dart.definiteFunctionType(html$._Attr, [core.String]),
[dartx.getNamedItemNS]: dart.definiteFunctionType(html$._Attr, [core.String, core.String]),
@@ -77937,8 +78685,8 @@
dart.registerExtension(dart.global.ServiceWorker, html$._ServiceWorker);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77953,11 +78701,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77986,7 +78734,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -78003,8 +78751,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.SpeechRecognitionResult, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.SpeechRecognitionResult]),
+ [dartx._get]: dart.definiteFunctionType(html$.SpeechRecognitionResult, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.SpeechRecognitionResult]),
[dartx.elementAt]: dart.definiteFunctionType(html$.SpeechRecognitionResult, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.SpeechRecognitionResult, [core.int])
})
@@ -78012,8 +78760,8 @@
dart.registerExtension(dart.global.SpeechRecognitionResultList, html$._SpeechRecognitionResultList);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -78028,11 +78776,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -78061,7 +78809,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__getter__](name) {
return this.__getter__(name);
@@ -78081,8 +78829,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.StyleSheet, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.StyleSheet]),
+ [dartx._get]: dart.definiteFunctionType(html$.StyleSheet, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.StyleSheet]),
[dartx.elementAt]: dart.definiteFunctionType(html$.StyleSheet, [core.int]),
[__getter__]: dart.definiteFunctionType(html$.CssStyleSheet, [core.String]),
[dartx.item]: dart.definiteFunctionType(html$.StyleSheet, [core.int])
@@ -78172,7 +78920,7 @@
}
addAll(other) {
other[dartx.forEach](dart.fn((k, v) => {
- this.set(k, v);
+ this._set(k, v);
}, StringAndStringTovoid$()));
}
containsValue(value) {
@@ -78185,9 +78933,9 @@
}
putIfAbsent(key, ifAbsent) {
if (!dart.test(this[dartx.containsKey](key))) {
- this.set(key, ifAbsent());
+ this._set(key, ifAbsent());
}
- return this.get(key);
+ return this._get(key);
}
clear() {
for (let key of this.keys) {
@@ -78196,7 +78944,7 @@
}
forEach(f) {
for (let key of this.keys) {
- let value = this.get(key);
+ let value = this._get(key);
f(key, value);
}
}
@@ -78204,7 +78952,7 @@
let attributes = this[_element$][_attributes$];
let keys = JSArrayOfString().of([]);
for (let i = 0, len = attributes[dartx.length]; i < dart.notNull(len); i++) {
- let attr = html$._Attr._check(attributes[dartx.get](i));
+ let attr = html$._Attr._check(attributes[dartx._get](i));
if (dart.test(this[_matches](attr))) {
keys[dartx.add](attr[dartx.name]);
}
@@ -78215,7 +78963,7 @@
let attributes = this[_element$][_attributes$];
let values = JSArrayOfString().of([]);
for (let i = 0, len = attributes[dartx.length]; i < dart.notNull(len); i++) {
- let attr = html$._Attr._check(attributes[dartx.get](i));
+ let attr = html$._Attr._check(attributes[dartx._get](i));
if (dart.test(this[_matches](attr))) {
values[dartx.add](attr[dartx.value]);
}
@@ -78265,10 +79013,10 @@
containsKey(key) {
return this[_element$][_hasAttribute](core.String._check(key));
}
- get(key) {
+ _get(key) {
return this[_element$][dartx.getAttribute](core.String._check(key));
}
- set(key, value) {
+ _set(key, value) {
this[_element$][dartx.setAttribute](key, value);
return value;
}
@@ -78289,16 +79037,16 @@
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
- get: dart.definiteFunctionType(core.String, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ _get: dart.definiteFunctionType(core.String, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
remove: dart.definiteFunctionType(core.String, [core.Object]),
[_matches]: dart.definiteFunctionType(core.bool, [html$.Node])
})
});
dart.defineExtensionMembers(html$._ElementAttributeMap, [
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'remove',
'length'
]);
@@ -78311,15 +79059,15 @@
containsKey(key) {
return this[_element$][_hasAttributeNS](this[_namespace], core.String._check(key));
}
- get(key) {
+ _get(key) {
return this[_element$][dartx.getAttributeNS](this[_namespace], core.String._check(key));
}
- set(key, value) {
+ _set(key, value) {
this[_element$][dartx.setAttributeNS](this[_namespace], key, value);
return value;
}
remove(key) {
- let value = this.get(key);
+ let value = this._get(key);
this[_element$][_removeAttributeNS](this[_namespace], core.String._check(key));
return value;
}
@@ -78336,16 +79084,16 @@
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
- get: dart.definiteFunctionType(core.String, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ _get: dart.definiteFunctionType(core.String, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
remove: dart.definiteFunctionType(core.String, [core.Object]),
[_matches]: dart.definiteFunctionType(core.bool, [html$.Node])
})
});
dart.defineExtensionMembers(html$._NamespacedAttributeMap, [
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'remove',
'length'
]);
@@ -78359,7 +79107,7 @@
}
addAll(other) {
other[dartx.forEach](dart.fn((k, v) => {
- this.set(k, v);
+ this._set(k, v);
}, StringAndStringTovoid$()));
}
containsValue(value) {
@@ -78368,11 +79116,11 @@
containsKey(key) {
return this[_attributes$][dartx.containsKey](this[_attr](core.String._check(key)));
}
- get(key) {
- return this[_attributes$][dartx.get](this[_attr](core.String._check(key)));
+ _get(key) {
+ return this[_attributes$][dartx._get](this[_attr](core.String._check(key)));
}
- set(key, value) {
- this[_attributes$][dartx.set](this[_attr](key), value);
+ _set(key, value) {
+ this[_attributes$][dartx._set](this[_attr](key), value);
return value;
}
putIfAbsent(key, ifAbsent) {
@@ -78434,9 +79182,9 @@
let segments = hyphenedName[dartx.split]('-');
let start = dart.test(startUppercase) ? 0 : 1;
for (let i = start; i < dart.notNull(segments[dartx.length]); i++) {
- let segment = segments[dartx.get](i);
+ let segment = segments[dartx._get](i);
if (dart.notNull(segment[dartx.length]) > 0) {
- segments[dartx.set](i, dart.str`${segment[dartx.get](0)[dartx.toUpperCase]()}${segment[dartx.substring](1)}`);
+ segments[dartx._set](i, dart.str`${segment[dartx._get](0)[dartx.toUpperCase]()}${segment[dartx.substring](1)}`);
}
}
return segments[dartx.join]('');
@@ -78444,8 +79192,8 @@
[_toHyphenedName](word) {
let sb = new core.StringBuffer();
for (let i = 0; i < dart.notNull(word[dartx.length]); i++) {
- let lower = word[dartx.get](i)[dartx.toLowerCase]();
- if (word[dartx.get](i) != lower && i > 0) sb.write('-');
+ let lower = word[dartx._get](i)[dartx.toLowerCase]();
+ if (word[dartx._get](i) != lower && i > 0) sb.write('-');
sb.write(lower);
}
return sb.toString();
@@ -78466,8 +79214,8 @@
addAll: dart.definiteFunctionType(dart.void, [MapOfString$String()]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
- get: dart.definiteFunctionType(core.String, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ _get: dart.definiteFunctionType(core.String, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
putIfAbsent: dart.definiteFunctionType(core.String, [core.String, VoidToString()]),
remove: dart.definiteFunctionType(core.String, [core.Object]),
clear: dart.definiteFunctionType(dart.void, []),
@@ -78483,8 +79231,8 @@
'addAll',
'containsValue',
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -80030,7 +80778,7 @@
add(stream) {
StreamOfT()._check(stream);
if (dart.test(this[_subscriptions][dartx.containsKey](stream))) return;
- this[_subscriptions][dartx.set](stream, stream.listen(dart.bind(this[_controller$0], 'add'), {onError: dart.bind(this[_controller$0], 'addError'), onDone: dart.fn(() => this.remove(stream), VoidTovoid$())}));
+ this[_subscriptions][dartx._set](stream, stream.listen(dart.bind(this[_controller$0], 'add'), {onError: dart.bind(this[_controller$0], 'addError'), onDone: dart.fn(() => this.remove(stream), VoidTovoid$())}));
}
remove(stream) {
StreamOfT()._check(stream);
@@ -80114,10 +80862,10 @@
this.uriPolicy = uriPolicy != null ? uriPolicy : html$.UriPolicy.new();
if (dart.test(html$._Html5NodeValidator._attributeValidators[dartx.isEmpty])) {
for (let attr of html$._Html5NodeValidator._standardAttributes) {
- html$._Html5NodeValidator._attributeValidators[dartx.set](attr, html$._Html5NodeValidator._standardAttributeValidator);
+ html$._Html5NodeValidator._attributeValidators[dartx._set](attr, html$._Html5NodeValidator._standardAttributeValidator);
}
for (let attr of html$._Html5NodeValidator._uriAttributes) {
- html$._Html5NodeValidator._attributeValidators[dartx.set](attr, html$._Html5NodeValidator._uriAttributeValidator);
+ html$._Html5NodeValidator._attributeValidators[dartx._set](attr, html$._Html5NodeValidator._uriAttributeValidator);
}
}
}
@@ -80126,9 +80874,9 @@
}
allowsAttribute(element, attributeName, value) {
let tagName = html$.Element._safeTagName(element);
- let validator = html$._Html5NodeValidator._attributeValidators[dartx.get](dart.str`${tagName}::${attributeName}`);
+ let validator = html$._Html5NodeValidator._attributeValidators[dartx._get](dart.str`${tagName}::${attributeName}`);
if (validator == null) {
- validator = html$._Html5NodeValidator._attributeValidators[dartx.get](dart.str`*::${attributeName}`);
+ validator = html$._Html5NodeValidator._attributeValidators[dartx._get](dart.str`*::${attributeName}`);
}
if (validator == null) {
return false;
@@ -80959,7 +81707,7 @@
if (prevEvent[_shadowCharCode] == event[dartx.charCode]) {
return prevEvent.keyCode;
}
- if ((dart.test(event[dartx.shiftKey]) || dart.test(this[_capsLockOn])) && dart.notNull(event[dartx.charCode]) >= dart.notNull("A"[dartx.codeUnits][dartx.get](0)) && dart.notNull(event[dartx.charCode]) <= dart.notNull("Z"[dartx.codeUnits][dartx.get](0)) && dart.notNull(event[dartx.charCode]) + dart.notNull(html$._KeyboardEventHandler._ROMAN_ALPHABET_OFFSET) == prevEvent[_shadowCharCode]) {
+ if ((dart.test(event[dartx.shiftKey]) || dart.test(this[_capsLockOn])) && dart.notNull(event[dartx.charCode]) >= dart.notNull("A"[dartx.codeUnits][dartx._get](0)) && dart.notNull(event[dartx.charCode]) <= dart.notNull("Z"[dartx.codeUnits][dartx._get](0)) && dart.notNull(event[dartx.charCode]) + dart.notNull(html$._KeyboardEventHandler._ROMAN_ALPHABET_OFFSET) == prevEvent[_shadowCharCode]) {
return prevEvent.keyCode;
}
}
@@ -81157,7 +81905,7 @@
}
e[_shadowKeyCode] = this[_determineKeyCodeForKeypress](e);
if (e[_shadowKeyIdentifier] != null && dart.test(html$._KeyboardEventHandler._keyIdentifier[dartx.containsKey](e[_shadowKeyIdentifier]))) {
- e[_shadowKeyCode] = html$._KeyboardEventHandler._keyIdentifier[dartx.get](e[_shadowKeyIdentifier]);
+ e[_shadowKeyCode] = html$._KeyboardEventHandler._keyIdentifier[dartx._get](e[_shadowKeyIdentifier]);
}
e[_shadowAltKey] = this[_keyDownList][dartx.any](dart.fn(element => element.altKey, KeyEventTobool()));
this[_stream$].add(e);
@@ -81212,7 +81960,7 @@
html$._KeyboardEventHandler._keyIdentifier = dart.const(dart.map({Up: html$.KeyCode.UP, Down: html$.KeyCode.DOWN, Left: html$.KeyCode.LEFT, Right: html$.KeyCode.RIGHT, Enter: html$.KeyCode.ENTER, F1: html$.KeyCode.F1, F2: html$.KeyCode.F2, F3: html$.KeyCode.F3, F4: html$.KeyCode.F4, F5: html$.KeyCode.F5, F6: html$.KeyCode.F6, F7: html$.KeyCode.F7, F8: html$.KeyCode.F8, F9: html$.KeyCode.F9, F10: html$.KeyCode.F10, F11: html$.KeyCode.F11, F12: html$.KeyCode.F12, 'U+007F': html$.KeyCode.DELETE, Home: html$.KeyCode.HOME, End: html$.KeyCode.END, PageUp: html$.KeyCode.PAGE_UP, PageDown: html$.KeyCode.PAGE_DOWN, Insert: html$.KeyCode.INSERT}, core.String, core.int));
dart.defineLazy(html$._KeyboardEventHandler, {
get _ROMAN_ALPHABET_OFFSET() {
- return dart.notNull("a"[dartx.codeUnits][dartx.get](0)) - dart.notNull("A"[dartx.codeUnits][dartx.get](0));
+ return dart.notNull("a"[dartx.codeUnits][dartx._get](0)) - dart.notNull("A"[dartx.codeUnits][dartx._get](0));
}
});
html$.KeyboardEventStream = class KeyboardEventStream extends core.Object {
@@ -81430,7 +82178,7 @@
}
allowsElement(element) {
if (dart.test(this.allowTypeExtension)) {
- let isAttr = element[dartx.attributes][dartx.get]('is');
+ let isAttr = element[dartx.attributes][dartx._get]('is');
if (isAttr != null) {
return dart.test(this.allowedElements.contains(isAttr[dartx.toUpperCase]())) && dart.test(this.allowedElements.contains(html$.Element._safeTagName(element)));
}
@@ -81467,7 +82215,7 @@
if (attributeName == 'template' && value == "") {
return true;
}
- if (element[dartx.attributes][dartx.get]('template') == "") {
+ if (element[dartx.attributes][dartx._get]('template') == "") {
return this[_templateAttrs].contains(attributeName);
}
return false;
@@ -81542,12 +82290,12 @@
clear() {
this[_list$][dartx.clear]();
}
- get(index) {
- return html$._downcast(html$.Node, E)(this[_list$][dartx.get](index));
+ _get(index) {
+ return html$._downcast(html$.Node, E)(this[_list$][dartx._get](index));
}
- set(index, value) {
+ _set(index, value) {
E._check(value);
- this[_list$][dartx.set](index, value);
+ this[_list$][dartx._set](index, value);
return value;
}
set length(newLength) {
@@ -81605,8 +82353,8 @@
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
add: dart.definiteFunctionType(dart.void, [E]),
- get: dart.definiteFunctionType(E, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _get: dart.definiteFunctionType(E, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
sort: dart.definiteFunctionType(dart.void, [], [EAndEToint()]),
insert: dart.definiteFunctionType(dart.void, [core.int, E]),
removeAt: dart.definiteFunctionType(E, [core.int]),
@@ -81619,8 +82367,8 @@
'add',
'remove',
'clear',
- 'get',
- 'set',
+ '_get',
+ '_set',
'sort',
'indexOf',
'lastIndexOf',
@@ -81701,7 +82449,7 @@
moveNext() {
let nextPosition = dart.notNull(this[_position$0]) + 1;
if (nextPosition < dart.notNull(this[_length$2])) {
- this[_current$4] = this[_array][dartx.get](nextPosition);
+ this[_current$4] = this[_array][dartx._get](nextPosition);
this[_position$0] = nextPosition;
return true;
}
@@ -81741,7 +82489,7 @@
moveNext() {
let nextPosition = dart.notNull(this[_position$0]) + 1;
if (nextPosition < dart.notNull(this[_array][dartx.length])) {
- this[_current$4] = this[_array][dartx.get](nextPosition);
+ this[_current$4] = this[_array][dartx._get](nextPosition);
this[_position$0] = nextPosition;
return true;
}
@@ -82326,9 +83074,9 @@
}
let keys = attrs[dartx.keys][dartx.toList]();
for (let i = dart.notNull(attrs[dartx.length]) - 1; i >= 0; --i) {
- let name = keys[dartx.get](i);
- if (!dart.test(this.validator.allowsAttribute(element, core.String._check(dart.dsend(name, 'toLowerCase')), core.String._check(attrs[dartx.get](name))))) {
- html$.window[dartx.console].warn('Removing disallowed attribute ' + dart.str`<${tag} ${name}="${attrs[dartx.get](name)}">`);
+ let name = keys[dartx._get](i);
+ if (!dart.test(this.validator.allowsAttribute(element, core.String._check(dart.dsend(name, 'toLowerCase')), core.String._check(attrs[dartx._get](name))))) {
+ html$.window[dartx.console].warn('Removing disallowed attribute ' + dart.str`<${tag} ${name}="${attrs[dartx._get](name)}">`);
attrs[dartx.remove](name);
}
}
@@ -82395,17 +83143,17 @@
findSlot(value) {
let length = this.values[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (core.identical(this.values[dartx.get](i), value)) return i;
+ if (core.identical(this.values[dartx._get](i), value)) return i;
}
this.values[dartx.add](value);
this.copies[dartx.add](null);
return length;
}
readSlot(i) {
- return this.copies[dartx.get](i);
+ return this.copies[dartx._get](i);
}
writeSlot(i, x) {
- this.copies[dartx.set](i, x);
+ this.copies[dartx._set](i, x);
}
cleanupSlots() {}
walk(e) {
@@ -82450,7 +83198,7 @@
let copy = this.newJsList(length);
this.writeSlot(slot, copy);
for (; i < dart.notNull(length); i++) {
- dart.dsetindex(copy, i, this.walk(e[dartx.get](i)));
+ dart.dsetindex(copy, i, this.walk(e[dartx._get](i)));
}
return copy;
}
@@ -82484,17 +83232,17 @@
findSlot(value) {
let length = this.values[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (dart.test(this.identicalInJs(this.values[dartx.get](i), value))) return i;
+ if (dart.test(this.identicalInJs(this.values[dartx._get](i), value))) return i;
}
this.values[dartx.add](value);
this.copies[dartx.add](null);
return length;
}
readSlot(i) {
- return this.copies[dartx.get](i);
+ return this.copies[dartx._get](i);
}
writeSlot(i, x) {
- this.copies[dartx.set](i, x);
+ this.copies[dartx._set](i, x);
}
walk(e) {
if (e == null) return e;
@@ -82627,7 +83375,7 @@
let dict = dart.map();
let keys = Object.getOwnPropertyNames(object);
for (let key of core.Iterable._check(keys)) {
- dict[dartx.set](key, object[key]);
+ dict[dartx._set](key, object[key]);
}
return dict;
};
@@ -82863,8 +83611,8 @@
forEach(f) {
this[_filtered][dartx.forEach](f);
}
- set(index, value) {
- this.get(index)[dartx.replaceWith](value);
+ _set(index, value) {
+ this._get(index)[dartx.replaceWith](value);
return value;
}
set length(newLength) {
@@ -82937,7 +83685,7 @@
}
}
removeAt(index) {
- let result = this.get(index);
+ let result = this._get(index);
result[dartx.remove]();
return result;
}
@@ -82953,7 +83701,7 @@
get length() {
return this[_iterable$0][dartx.length];
}
- get(index) {
+ _get(index) {
return this[_iterable$0][dartx.elementAt](index);
}
get iterator() {
@@ -82982,7 +83730,7 @@
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
forEach: dart.definiteFunctionType(dart.void, [ElementTovoid()]),
- set: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
add: dart.definiteFunctionType(dart.void, [html$.Element]),
addAll: dart.definiteFunctionType(dart.void, [IterableOfElement()]),
sort: dart.definiteFunctionType(dart.void, [], [ElementAndElementToint()]),
@@ -82993,12 +83741,12 @@
insert: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
insertAll: dart.definiteFunctionType(dart.void, [core.int, IterableOfElement()]),
removeAt: dart.definiteFunctionType(html$.Element, [core.int]),
- get: dart.definiteFunctionType(html$.Element, [core.int])
+ _get: dart.definiteFunctionType(html$.Element, [core.int])
})
});
dart.defineExtensionMembers(html_common.FilteredElementList, [
'forEach',
- 'set',
+ '_set',
'add',
'addAll',
'contains',
@@ -83013,7 +83761,7 @@
'insertAll',
'removeAt',
'remove',
- 'get',
+ '_get',
'length',
'reversed',
'length',
@@ -83028,7 +83776,7 @@
startIndex = 0;
}
for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dart.notNull(i) + 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -83042,7 +83790,7 @@
startIndex = dart.notNull(a[dartx.length]) - 1;
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -83053,7 +83801,7 @@
if (dart.notNull(end) < dart.notNull(start)) dart.throw(new core.RangeError.value(end));
if (dart.notNull(end) > dart.notNull(a[dartx.length])) dart.throw(new core.RangeError.value(end));
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- accumulator[dartx.add](a[dartx.get](i));
+ accumulator[dartx.add](a[dartx._get](i));
}
return accumulator;
}
@@ -86275,7 +87023,42 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get height() {
+ return this[height$];
+ }
+ set height(value) {
+ super.height = value;
+ }
+ get result() {
+ return this[result];
+ }
+ set result(value) {
+ super.result = value;
+ }
+ get width() {
+ return this[width$];
+ }
+ set width(value) {
+ super.width = value;
+ }
+ get x() {
+ return this[x];
+ }
+ set x(value) {
+ super.x = value;
+ }
+ get y() {
+ return this[y];
+ }
+ set y(value) {
+ super.y = value;
+ }
};
+ const height$ = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'height'.toString());
+ const result = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'result'.toString());
+ const width$ = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'width'.toString());
+ const x = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'x'.toString());
+ const y = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'y'.toString());
dart.setSignature(svg$.FilterPrimitiveStandardAttributes, {
constructors: () => ({_: dart.definiteFunctionType(svg$.FilterPrimitiveStandardAttributes, [])}),
fields: () => ({
@@ -86301,7 +87084,21 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get preserveAspectRatio() {
+ return this[preserveAspectRatio];
+ }
+ set preserveAspectRatio(value) {
+ super.preserveAspectRatio = value;
+ }
+ get viewBox() {
+ return this[viewBox];
+ }
+ set viewBox(value) {
+ super.viewBox = value;
+ }
};
+ const preserveAspectRatio = Symbol(svg$.FitToViewBox.name + "." + 'preserveAspectRatio'.toString());
+ const viewBox = Symbol(svg$.FitToViewBox.name + "." + 'viewBox'.toString());
dart.setSignature(svg$.FitToViewBox, {
constructors: () => ({_: dart.definiteFunctionType(svg$.FitToViewBox, [])}),
fields: () => ({
@@ -86524,8 +87321,8 @@
const __setter__$ = Symbol('__setter__');
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -86550,11 +87347,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -86583,7 +87380,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -86622,8 +87419,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg$.Length, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Length]),
+ [dartx._get]: dart.definiteFunctionType(svg$.Length, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Length]),
[dartx.elementAt]: dart.definiteFunctionType(svg$.Length, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, svg$.Length]),
[dartx.appendItem]: dart.definiteFunctionType(svg$.Length, [svg$.Length]),
@@ -87130,8 +87927,8 @@
dart.registerExtension(dart.global.SVGNumber, svg$.Number);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -87156,11 +87953,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -87189,7 +87986,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -87228,8 +88025,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg$.Number, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Number]),
+ [dartx._get]: dart.definiteFunctionType(svg$.Number, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Number]),
[dartx.elementAt]: dart.definiteFunctionType(svg$.Number, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, svg$.Number]),
[dartx.appendItem]: dart.definiteFunctionType(svg$.Number, [svg$.Number]),
@@ -88115,8 +88912,8 @@
dart.registerExtension(dart.global.SVGPathSegLinetoVerticalRel, svg$.PathSegLinetoVerticalRel);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -88141,11 +88938,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -88174,7 +88971,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -88213,8 +89010,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg$.PathSeg, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg$.PathSeg]),
+ [dartx._get]: dart.definiteFunctionType(svg$.PathSeg, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg$.PathSeg]),
[dartx.elementAt]: dart.definiteFunctionType(svg$.PathSeg, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, svg$.PathSeg]),
[dartx.appendItem]: dart.definiteFunctionType(svg$.PathSeg, [svg$.PathSeg]),
@@ -88880,8 +89677,8 @@
dart.registerExtension(dart.global.SVGStopElement, svg$.StopElement);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -88906,11 +89703,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -88939,7 +89736,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -88978,8 +89775,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.String, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
[dartx.elementAt]: dart.definiteFunctionType(core.String, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
[dartx.appendItem]: dart.definiteFunctionType(core.String, [core.String]),
@@ -89054,7 +89851,7 @@
this[_element$0] = element;
}
readClasses() {
- let classname = this[_element$0][dartx.attributes][dartx.get]('class');
+ let classname = this[_element$0][dartx.attributes][dartx._get]('class');
let s = LinkedHashSetOfString().new();
if (classname == null) {
return s;
@@ -89068,7 +89865,7 @@
return s;
}
writeClasses(s) {
- this[_element$0][dartx.attributes][dartx.set]('class', s.join(' '));
+ this[_element$0][dartx.attributes][dartx._set]('class', s.join(' '));
}
};
dart.setSignature(svg$._AttributeClassSet, {
@@ -89123,7 +89920,7 @@
svg$.SvgSvgElement = class SvgSvgElement extends svg$.GraphicsElement {
static new() {
let el = svg$.SvgElement.tag("svg");
- el[dartx.attributes][dartx.set]('version', "1.1");
+ el[dartx.attributes][dartx._set]('version', "1.1");
return svg$.SvgSvgElement._check(el);
}
static _() {
@@ -89548,7 +90345,28 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get requiredExtensions() {
+ return this[requiredExtensions];
+ }
+ set requiredExtensions(value) {
+ super.requiredExtensions = value;
+ }
+ get requiredFeatures() {
+ return this[requiredFeatures];
+ }
+ set requiredFeatures(value) {
+ super.requiredFeatures = value;
+ }
+ get systemLanguage() {
+ return this[systemLanguage];
+ }
+ set systemLanguage(value) {
+ super.systemLanguage = value;
+ }
};
+ const requiredExtensions = Symbol(svg$.Tests.name + "." + 'requiredExtensions'.toString());
+ const requiredFeatures = Symbol(svg$.Tests.name + "." + 'requiredFeatures'.toString());
+ const systemLanguage = Symbol(svg$.Tests.name + "." + 'systemLanguage'.toString());
dart.setSignature(svg$.Tests, {
constructors: () => ({_: dart.definiteFunctionType(svg$.Tests, [])}),
fields: () => ({
@@ -89735,8 +90553,8 @@
dart.registerExtension(dart.global.SVGTransform, svg$.Transform);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -89763,11 +90581,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -89796,7 +90614,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -89841,8 +90659,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg$.Transform, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Transform]),
+ [dartx._get]: dart.definiteFunctionType(svg$.Transform, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Transform]),
[dartx.elementAt]: dart.definiteFunctionType(svg$.Transform, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, svg$.Transform]),
[dartx.appendItem]: dart.definiteFunctionType(svg$.Transform, [svg$.Transform]),
@@ -89880,7 +90698,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get href() {
+ return this[href$0];
+ }
+ set href(value) {
+ super.href = value;
+ }
};
+ const href$0 = Symbol(svg$.UriReference.name + "." + 'href'.toString());
dart.setSignature(svg$.UriReference, {
constructors: () => ({_: dart.definiteFunctionType(svg$.UriReference, [])}),
fields: () => ({href: svg$.AnimatedString})
@@ -90062,7 +90887,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get zoomAndPan() {
+ return this[zoomAndPan];
+ }
+ set zoomAndPan(value) {
+ this[zoomAndPan] = value;
+ }
};
+ const zoomAndPan = Symbol(svg$.ZoomAndPan.name + "." + 'zoomAndPan'.toString());
dart.setSignature(svg$.ZoomAndPan, {
constructors: () => ({_: dart.definiteFunctionType(svg$.ZoomAndPan, [])}),
fields: () => ({zoomAndPan: core.int}),
@@ -93805,8 +94637,8 @@
const _item_1 = Symbol('_item_1');
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -93821,11 +94653,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.item](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -93854,7 +94686,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return html_common.convertNativeToDart_Dictionary(this[_item_1](index));
@@ -93874,8 +94706,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.Map, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, core.Map]),
+ [dartx._get]: dart.definiteFunctionType(core.Map, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, core.Map]),
[dartx.elementAt]: dart.definiteFunctionType(core.Map, [core.int]),
[dartx.item]: dart.definiteFunctionType(core.Map, [core.int]),
[_item_1]: dart.definiteFunctionType(dart.dynamic, [dart.dynamic])
diff --git a/pkg/dev_compiler/lib/js/es6/dart_sdk.js b/pkg/dev_compiler/lib/js/es6/dart_sdk.js
index c5e550d..cd79fe3 100644
--- a/pkg/dev_compiler/lib/js/es6/dart_sdk.js
+++ b/pkg/dev_compiler/lib/js/es6/dart_sdk.js
@@ -1034,7 +1034,6 @@
let proto = type.prototype;
for (let name of methodNames) {
let method = dart.getOwnPropertyDescriptor(proto, name);
- if (!method) continue;
dart.defineProperty(proto, dart.getExtensionSymbol(name), method);
}
let originalSigFn = dart.getOwnPropertyDescriptor(type, dart._methodSig).get;
@@ -1601,9 +1600,9 @@
dart.getDynamicStats = function() {
let ret = JSArrayOfListOfObject().of([]);
let keys = dart._callMethodStats[dartx.keys][dartx.toList]();
- keys[dartx.sort](dart.fn((a, b) => dart._callMethodStats[dartx.get](b).count[dartx.compareTo](dart._callMethodStats[dartx.get](a).count), StringAndStringToint()));
+ keys[dartx.sort](dart.fn((a, b) => dart._callMethodStats[dartx._get](b).count[dartx.compareTo](dart._callMethodStats[dartx._get](a).count), StringAndStringToint()));
for (let key of keys) {
- let stats = dart._callMethodStats[dartx.get](key);
+ let stats = dart._callMethodStats[dartx._get](key);
ret[dartx.add](JSArrayOfObject().of([stats.typeName, stats.frame, stats.count]));
}
return ret;
@@ -1618,7 +1617,7 @@
let stack = stackStr[dartx.split]('\n at ');
let src = '';
for (let i = 2; i < dart.notNull(stack[dartx.length]); ++i) {
- let frame = stack[dartx.get](i);
+ let frame = stack[dartx._get](i);
if (!dart.test(frame[dartx.contains]('dart_sdk.js'))) {
src = frame;
break;
@@ -1644,10 +1643,10 @@
return dart._callMethod(obj, method, typeArgs, args, method);
};
dart.dindex = function(obj, index) {
- return dart._callMethod(obj, 'get', null, [index], '[]');
+ return dart._callMethod(obj, '_get', null, [index], '[]');
};
dart.dsetindex = function(obj, index, value) {
- return dart._callMethod(obj, 'set', null, [index, value], '[]=');
+ return dart._callMethod(obj, '_set', null, [index, value], '[]=');
};
dart._ignoreMemo = function(f) {
let memo = new Map();
@@ -1770,11 +1769,11 @@
for (let i = 0, end = values.length - 1; i < end; i += 2) {
let key = values[i];
let value = values[i + 1];
- map.set(key, value);
+ map._set(key, value);
}
} else if (typeof values === 'object') {
for (let key of dart.getOwnPropertyNames(values)) {
- map.set(key, values[key]);
+ map._set(key, values[key]);
}
}
return map;
@@ -3114,7 +3113,7 @@
if (genericTypeConstructor != null) {
this.recordGenericParameters(core.String._check(name), genericTypeConstructor);
} else {
- nonGenericProperties.set(core.String._check(name), value);
+ nonGenericProperties._set(core.String._check(name), value);
}
}, dynamicAnddynamicTodynamic()));
nonGenericProperties.forEach(dart.fn((name, value) => {
@@ -3127,13 +3126,13 @@
return children.toList();
}
recordGenericParameters(name, genericTypeConstructor) {
- this.genericParameters.set(name, genericTypeConstructor.toString()[dartx.split](' =>')[dartx.first][dartx.replaceAll](core.RegExp.new('[(|)]'), ''));
+ this.genericParameters._set(name, genericTypeConstructor.toString()[dartx.split](' =>')[dartx.first][dartx.replaceAll](core.RegExp.new('[(|)]'), ''));
}
classChild(name, child) {
let typeName = _debugger.getTypeName(core.Type._check(child));
let parameterName = dart.str`${name}\$`;
if (dart.test(this.genericParameters.keys[dartx.contains](parameterName))) {
- typeName = dart.str`${typeName}<${this.genericParameters.get(parameterName)}>`;
+ typeName = dart.str`${typeName}<${this.genericParameters._get(parameterName)}>`;
_debugger.JSNative.setProperty(child, 'genericTypeName', typeName);
}
return new _debugger.NameValuePair({name: typeName, value: child});
@@ -3723,8 +3722,8 @@
'hashCode',
'length',
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'asMap'
]);
class JSArray extends core.Object {
@@ -3801,7 +3800,7 @@
this[dartx.checkMutable]('setAll');
core.RangeError.checkValueInInterval(index, 0, this[dartx.length], "index");
for (let element of iterable) {
- this[dartx.set]((() => {
+ this[dartx._set]((() => {
let x = index;
index = dart.notNull(x) + 1;
return x;
@@ -3816,7 +3815,7 @@
[dartx.remove](element) {
this[dartx.checkGrowable]('remove');
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
this.splice(i, 1);
return true;
}
@@ -3844,7 +3843,7 @@
if (retained[dartx.length] == end) return;
this[dartx.length] = retained[dartx.length];
for (let i = 0; i < dart.notNull(retained[dartx.length]); i++) {
- this[dartx.set](i, E._check(retained[dartx.get](i)));
+ this[dartx._set](i, E._check(retained[dartx._get](i)));
}
}
[dartx.where](f) {
@@ -3885,7 +3884,7 @@
if (separator === void 0) separator = "";
let list = core.List.new(this[dartx.length]);
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- list[dartx.set](i, dart.str`${this[dartx.get](i)}`);
+ list[dartx._set](i, dart.str`${this[dartx._get](i)}`);
}
return list.join(separator);
}
@@ -3905,7 +3904,7 @@
EAndEToE()._check(combine);
let length = this[dartx.length];
if (length == 0) dart.throw(_internal.IterableElementError.noElement());
- let value = this[dartx.get](0);
+ let value = this[dartx._get](0);
for (let i = 1; i < dart.notNull(length); i++) {
let element = this[i];
value = combine(value, element);
@@ -3972,7 +3971,7 @@
dart.throw(_internal.IterableElementError.noElement());
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.sublist](start, end) {
if (end === void 0) end = null;
@@ -3997,15 +3996,15 @@
return new (SubListIterableOfE())(this, start, end);
}
get [dartx.first]() {
- if (dart.notNull(this[dartx.length]) > 0) return this[dartx.get](0);
+ if (dart.notNull(this[dartx.length]) > 0) return this[dartx._get](0);
dart.throw(_internal.IterableElementError.noElement());
}
get [dartx.last]() {
- if (dart.notNull(this[dartx.length]) > 0) return this[dartx.get](dart.notNull(this[dartx.length]) - 1);
+ if (dart.notNull(this[dartx.length]) > 0) return this[dartx._get](dart.notNull(this[dartx.length]) - 1);
dart.throw(_internal.IterableElementError.noElement());
}
get [dartx.single]() {
- if (this[dartx.length] == 1) return this[dartx.get](0);
+ if (this[dartx.length] == 1) return this[dartx._get](0);
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
dart.throw(_internal.IterableElementError.tooMany());
}
@@ -4037,12 +4036,12 @@
}
if (dart.notNull(otherStart) < dart.notNull(start)) {
for (let i = length - 1; i >= 0; i--) {
- let element = otherList[dartx.get](dart.notNull(otherStart) + i);
+ let element = otherList[dartx._get](dart.notNull(otherStart) + i);
this[dart.notNull(start) + i] = element;
}
} else {
for (let i = 0; i < length; i++) {
- let element = otherList[dartx.get](dart.notNull(otherStart) + i);
+ let element = otherList[dartx._get](dart.notNull(otherStart) + i);
this[dart.notNull(start) + i] = element;
}
}
@@ -4121,9 +4120,9 @@
while (dart.notNull(length) > 1) {
let pos = random.nextInt(length);
length = dart.notNull(length) - 1;
- let tmp = this[dartx.get](length);
- this[dartx.set](length, this[dartx.get](pos));
- this[dartx.set](pos, tmp);
+ let tmp = this[dartx._get](length);
+ this[dartx._set](length, this[dartx._get](pos));
+ this[dartx._set](pos, tmp);
}
}
[dartx.indexOf](element, start) {
@@ -4135,7 +4134,7 @@
start = 0;
}
for (let i = start; dart.notNull(i) < dart.notNull(this[dartx.length]); i = dart.notNull(i) + 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -4154,7 +4153,7 @@
}
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -4162,7 +4161,7 @@
}
[dartx.contains](other) {
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), other)) return true;
+ if (dart.equals(this[dartx._get](i), other)) return true;
}
return false;
}
@@ -4203,12 +4202,12 @@
}
this.length = newLength;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (!(typeof index == 'number')) dart.throw(_js_helper.diagnoseIndexError(this, index));
if (dart.notNull(index) >= dart.notNull(this[dartx.length]) || dart.notNull(index) < 0) dart.throw(_js_helper.diagnoseIndexError(this, index));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
E._check(value);
this[dartx.checkMutable]('indexed set');
if (!(typeof index == 'number')) dart.throw(_js_helper.diagnoseIndexError(this, index));
@@ -4287,8 +4286,8 @@
[dartx.contains]: dart.definiteFunctionType(core.bool, [core.Object]),
[dartx.toList]: dart.definiteFunctionType(core.List$(E), [], {growable: core.bool}),
[dartx.toSet]: dart.definiteFunctionType(core.Set$(E), []),
- [dartx.get]: dart.definiteFunctionType(E, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, E]),
+ [dartx._get]: dart.definiteFunctionType(E, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, E]),
[dartx.asMap]: dart.definiteFunctionType(core.Map$(core.int, E), [])
}),
statics: () => ({
@@ -4363,7 +4362,7 @@
this[_current] = null;
return false;
}
- this[_current] = this[_iterable][dartx.get](this[_index]);
+ this[_current] = this[_iterable][dartx._get](this[_index]);
this[_index] = dart.notNull(this[_index]) + 1;
return true;
}
@@ -4415,7 +4414,7 @@
'toRadixString',
'toString',
'hashCode',
- 'unary-',
+ '_negate',
'+',
'-',
'/',
@@ -4612,7 +4611,7 @@
get [dartx.hashCode]() {
return this & 0x1FFFFFFF;
}
- [dartx['unary-']]() {
+ [dartx._negate]() {
return -this;
}
[dartx['+']](other) {
@@ -4910,7 +4909,7 @@
[dartx.toStringAsExponential]: dart.definiteFunctionType(core.String, [], [core.int]),
[dartx.toStringAsPrecision]: dart.definiteFunctionType(core.String, [core.int]),
[dartx.toRadixString]: dart.definiteFunctionType(core.String, [core.int]),
- [dartx['unary-']]: dart.definiteFunctionType(_interceptors.JSNumber, []),
+ [dartx._negate]: dart.definiteFunctionType(_interceptors.JSNumber, []),
[dartx['+']]: dart.definiteFunctionType(_interceptors.JSNumber, [core.num]),
[dartx['-']]: dart.definiteFunctionType(_interceptors.JSNumber, [core.num]),
[dartx['/']]: dart.definiteFunctionType(core.double, [core.num]),
@@ -4993,7 +4992,7 @@
'hashCode',
'runtimeType',
'length',
- 'get'
+ '_get'
]);
_interceptors.JSString = class JSString extends _interceptors.Interceptor {
new() {
@@ -5376,7 +5375,7 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (!(typeof index == 'number')) dart.throw(_js_helper.diagnoseIndexError(this, index));
if (dart.notNull(index) >= dart.notNull(this[dartx.length]) || dart.notNull(index) < 0) dart.throw(_js_helper.diagnoseIndexError(this, index));
return this[index];
@@ -5420,7 +5419,7 @@
[dartx.lastIndexOf]: dart.definiteFunctionType(core.int, [core.Pattern], [core.int]),
[dartx.contains]: dart.definiteFunctionType(core.bool, [core.Pattern], [core.int]),
[dartx.compareTo]: dart.definiteFunctionType(core.int, [core.String]),
- [dartx.get]: dart.definiteFunctionType(core.String, [core.int])
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.int])
}),
statics: () => ({
_isWhitespace: dart.definiteFunctionType(core.bool, [core.int]),
@@ -5572,12 +5571,12 @@
return new dart.JsIterator(this[dartx.iterator]);
}
elementAt(index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
forEach(action) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- action(this[dartx.get](i));
+ action(this[dartx._get](i));
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5591,21 +5590,21 @@
}
get first() {
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
- return this[dartx.get](0);
+ return this[dartx._get](0);
}
get last() {
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
- return this[dartx.get](dart.notNull(this[dartx.length]) - 1);
+ return this[dartx._get](dart.notNull(this[dartx.length]) - 1);
}
get single() {
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
if (dart.notNull(this[dartx.length]) > 1) dart.throw(_internal.IterableElementError.tooMany());
- return this[dartx.get](0);
+ return this[dartx._get](0);
}
contains(element) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), element)) return true;
+ if (dart.equals(this[dartx._get](i), element)) return true;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5615,7 +5614,7 @@
every(test) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (!dart.test(test(this[dartx.get](i)))) return false;
+ if (!dart.test(test(this[dartx._get](i)))) return false;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5625,7 +5624,7 @@
any(test) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (dart.test(test(this[dartx.get](i)))) return true;
+ if (dart.test(test(this[dartx._get](i)))) return true;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5637,7 +5636,7 @@
VoidToE()._check(orElse);
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- let element = this[dartx.get](i);
+ let element = this[dartx._get](i);
if (dart.test(test(element))) return element;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
@@ -5651,7 +5650,7 @@
VoidToE()._check(orElse);
let length = this[dartx.length];
for (let i = dart.notNull(length) - 1; i >= 0; i--) {
- let element = this[dartx.get](i);
+ let element = this[dartx._get](i);
if (dart.test(test(element))) return element;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
@@ -5665,7 +5664,7 @@
let match = null;
let matchFound = false;
for (let i = 0; i < dart.notNull(length); i++) {
- let element = this[dartx.get](i);
+ let element = this[dartx._get](i);
if (dart.test(test(element))) {
if (matchFound) {
dart.throw(_internal.IterableElementError.tooMany());
@@ -5704,9 +5703,9 @@
EAndEToE()._check(combine);
let length = this[dartx.length];
if (length == 0) dart.throw(_internal.IterableElementError.noElement());
- let value = this[dartx.get](0);
+ let value = this[dartx._get](0);
for (let i = 1; i < dart.notNull(length); i++) {
- value = combine(value, this[dartx.get](i));
+ value = combine(value, this[dartx._get](i));
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5718,7 +5717,7 @@
let value = initialValue;
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- value = combine(value, this[dartx.get](i));
+ value = combine(value, this[dartx._get](i));
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5748,20 +5747,20 @@
result = ListOfE().new(this[dartx.length]);
}
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- result[dartx.set](i, this[dartx.get](i));
+ result[dartx._set](i, this[dartx._get](i));
}
return result;
}
toSet() {
let result = SetOfE().new();
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- result.add(this[dartx.get](i));
+ result.add(this[dartx._get](i));
}
return result;
}
add(element) {
E._check(element);
- this[dartx.set]((() => {
+ this[dartx._set]((() => {
let x = this[dartx.length];
this[dartx.length] = dart.notNull(x) + 1;
return x;
@@ -5773,13 +5772,13 @@
for (let element of iterable) {
dart.assert(this[dartx.length] == i || dart.test(dart.throw(new core.ConcurrentModificationError(this))));
this[dartx.length] = dart.notNull(i) + 1;
- this[dartx.set](i, element);
+ this[dartx._set](i, element);
i = dart.notNull(i) + 1;
}
}
remove(element) {
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
this[dartx.setRange](i, dart.notNull(this[dartx.length]) - 1, this, i + 1);
this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
return true;
@@ -5797,7 +5796,7 @@
let retained = [];
let length = source[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- let element = source[dartx.get](i);
+ let element = source[dartx._get](i);
if (dart.dcall(test, element) == retainMatching) {
retained[dartx.add](element);
}
@@ -5817,7 +5816,7 @@
if (this[dartx.length] == 0) {
dart.throw(_internal.IterableElementError.noElement());
}
- let result = this[dartx.get](dart.notNull(this[dartx.length]) - 1);
+ let result = this[dartx._get](dart.notNull(this[dartx.length]) - 1);
this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
return result;
}
@@ -5836,9 +5835,9 @@
while (dart.notNull(length) > 1) {
let pos = random.nextInt(length);
length = dart.notNull(length) - 1;
- let tmp = this[dartx.get](length);
- this[dartx.set](length, this[dartx.get](pos));
- this[dartx.set](pos, tmp);
+ let tmp = this[dartx._get](length);
+ this[dartx._set](length, this[dartx._get](pos));
+ this[dartx._set](pos, tmp);
}
}
asMap() {
@@ -5853,7 +5852,7 @@
let result = ListOfE().new();
result[dartx.length] = length;
for (let i = 0; i < length; i++) {
- result[dartx.set](i, this[dartx.get](dart.notNull(start) + i));
+ result[dartx._set](i, this[dartx._get](dart.notNull(start) + i));
}
return result;
}
@@ -5872,7 +5871,7 @@
E._check(fill);
core.RangeError.checkValidRange(start, end, this[dartx.length]);
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- this[dartx.set](i, fill);
+ this[dartx._set](i, fill);
}
}
setRange(start, end, iterable, skipCount) {
@@ -5896,11 +5895,11 @@
}
if (dart.notNull(otherStart) < dart.notNull(start)) {
for (let i = length - 1; i >= 0; i--) {
- this[dartx.set](dart.notNull(start) + i, otherList[dartx.get](dart.notNull(otherStart) + i));
+ this[dartx._set](dart.notNull(start) + i, otherList[dartx._get](dart.notNull(otherStart) + i));
}
} else {
for (let i = 0; i < length; i++) {
- this[dartx.set](dart.notNull(start) + i, otherList[dartx.get](dart.notNull(otherStart) + i));
+ this[dartx._set](dart.notNull(start) + i, otherList[dartx._get](dart.notNull(otherStart) + i));
}
}
}
@@ -5939,7 +5938,7 @@
startIndex = 0;
}
for (let i = startIndex; dart.notNull(i) < dart.notNull(this[dartx.length]); i = dart.notNull(i) + 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -5958,7 +5957,7 @@
}
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -5974,10 +5973,10 @@
if (!(typeof index == 'number')) dart.throw(new core.ArgumentError(index));
this[dartx.length] = dart.notNull(this[dartx.length]) + 1;
this[dartx.setRange](dart.notNull(index) + 1, this[dartx.length], this, index);
- this[dartx.set](index, element);
+ this[dartx._set](index, element);
}
removeAt(index) {
- let result = this[dartx.get](index);
+ let result = this[dartx._get](index);
this[dartx.setRange](index, dart.notNull(this[dartx.length]) - 1, this, dart.notNull(index) + 1);
this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
return result;
@@ -6003,7 +6002,7 @@
this[dartx.setRange](index, dart.notNull(index) + dart.notNull(iterable[dartx.length]), iterable);
} else {
for (let element of iterable) {
- this[dartx.set]((() => {
+ this[dartx._set]((() => {
let x = index;
index = dart.notNull(x) + 1;
return x;
@@ -6152,7 +6151,7 @@
let ETobool = () => (ETobool = dart.constFn(dart.functionType(core.bool, [E])))();
let ComparatorOfE = () => (ComparatorOfE = dart.constFn(core.Comparator$(E)))();
class UnmodifiableListMixin extends core.Object {
- set(index, value) {
+ _set(index, value) {
E._check(value);
dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable list"));
return value;
@@ -6229,7 +6228,7 @@
dart.setSignature(UnmodifiableListMixin, {
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
setAll: dart.definiteFunctionType(dart.void, [core.int, IterableOfE()]),
add: dart.definiteFunctionType(dart.void, [E]),
insert: dart.definiteFunctionType(dart.void, [core.int, E]),
@@ -6250,7 +6249,7 @@
})
});
dart.defineExtensionMembers(UnmodifiableListMixin, [
- 'set',
+ '_set',
'setAll',
'add',
'insert',
@@ -6319,7 +6318,7 @@
set length(value) {
super.length = value;
}
- get(i) {
+ _get(i) {
return this[_string][dartx.codeUnitAt](i);
}
static stringOf(u) {
@@ -6331,11 +6330,11 @@
constructors: () => ({new: dart.definiteFunctionType(_internal.CodeUnits, [core.String])}),
fields: () => ({[_string]: core.String}),
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
- methods: () => ({get: dart.definiteFunctionType(core.int, [core.int])}),
+ methods: () => ({_get: dart.definiteFunctionType(core.int, [core.int])}),
statics: () => ({stringOf: dart.definiteFunctionType(core.String, [_internal.CodeUnits])}),
names: ['stringOf']
});
-dart.defineExtensionMembers(_internal.CodeUnits, ['get', 'length']);
+dart.defineExtensionMembers(_internal.CodeUnits, ['_get', 'length']);
_internal.EfficientLength = class EfficientLength extends core.Object {};
core.Iterable$ = dart.generic(E => {
let EmptyIterableOfE = () => (EmptyIterableOfE = dart.constFn(_internal.EmptyIterable$(E)))();
@@ -6854,7 +6853,7 @@
result = ListOfE().new(this.length);
}
for (let i = 0; i < dart.notNull(this.length); i++) {
- result[dartx.set](i, this.elementAt(i));
+ result[dartx._set](i, this.elementAt(i));
}
return result;
}
@@ -7002,7 +7001,7 @@
return _;
})() : ListOfE().new(length);
for (let i = 0; i < length; i++) {
- result[dartx.set](i, this[_iterable][dartx.elementAt](dart.notNull(start) + i));
+ result[dartx._set](i, this[_iterable][dartx.elementAt](dart.notNull(start) + i));
if (dart.notNull(this[_iterable][dartx.length]) < dart.notNull(end)) dart.throw(new core.ConcurrentModificationError(this));
}
return result;
@@ -8052,8 +8051,8 @@
new(values) {
this[_values] = values;
}
- get(key) {
- return dart.test(this.containsKey(key)) ? this[_values][dartx.get](core.int._check(key)) : null;
+ _get(key) {
+ return dart.test(this.containsKey(key)) ? this[_values][dartx._get](core.int._check(key)) : null;
}
get length() {
return this[_values][dartx.length];
@@ -8079,13 +8078,13 @@
forEach(f) {
let length = this[_values][dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- f(i, this[_values][dartx.get](i));
+ f(i, this[_values][dartx._get](i));
if (length != this[_values][dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this[_values]));
}
}
}
- set(key, value) {
+ _set(key, value) {
E._check(value);
dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable map"));
return value;
@@ -8121,11 +8120,11 @@
isNotEmpty: dart.definiteFunctionType(core.bool, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(E, [core.Object]),
+ _get: dart.definiteFunctionType(E, [core.Object]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
forEach: dart.definiteFunctionType(dart.void, [intAndETovoid()]),
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
putIfAbsent: dart.definiteFunctionType(E, [core.int, VoidToE()]),
remove: dart.definiteFunctionType(E, [core.Object]),
clear: dart.definiteFunctionType(dart.void, []),
@@ -8133,11 +8132,11 @@
})
});
dart.defineExtensionMembers(ListMapView, [
- 'get',
+ '_get',
'containsValue',
'containsKey',
'forEach',
- 'set',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -8234,11 +8233,11 @@
static copy(src, srcStart, dst, dstStart, count) {
if (dart.notNull(srcStart) < dart.notNull(dstStart)) {
for (let i = dart.notNull(srcStart) + dart.notNull(count) - 1, j = dart.notNull(dstStart) + dart.notNull(count) - 1; i >= dart.notNull(srcStart); i--, j--) {
- dst[dartx.set](j, src[dartx.get](i));
+ dst[dartx._set](j, src[dartx._get](i));
}
} else {
for (let i = srcStart, j = dstStart; dart.notNull(i) < dart.notNull(srcStart) + dart.notNull(count); i = dart.notNull(i) + 1, j = dart.notNull(j) + 1) {
- dst[dartx.set](j, src[dartx.get](i));
+ dst[dartx._set](j, src[dartx._get](i));
}
}
}
@@ -8248,7 +8247,7 @@
let length = a[dartx.length];
if (!dart.equals(length, dart.dload(b, 'length'))) return false;
for (let i = 0; i < dart.notNull(length); i++) {
- if (!core.identical(a[dartx.get](i), dart.dindex(b, i))) return false;
+ if (!core.identical(a[dartx._get](i), dart.dindex(b, i))) return false;
}
return true;
}
@@ -8260,7 +8259,7 @@
startIndex = 0;
}
for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dart.notNull(i) + 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -8274,7 +8273,7 @@
startIndex = dart.notNull(a[dartx.length]) - 1;
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -8334,13 +8333,13 @@
static _insertionSort(E) {
return (a, left, right, compare) => {
for (let i = dart.notNull(left) + 1; i <= dart.notNull(right); i++) {
- let el = a[dartx.get](i);
+ let el = a[dartx._get](i);
let j = i;
- while (j > dart.notNull(left) && dart.notNull(compare(a[dartx.get](j - 1), el)) > 0) {
- a[dartx.set](j, a[dartx.get](j - 1));
+ while (j > dart.notNull(left) && dart.notNull(compare(a[dartx._get](j - 1), el)) > 0) {
+ a[dartx._set](j, a[dartx._get](j - 1));
j--;
}
- a[dartx.set](j, el);
+ a[dartx._set](j, el);
}
};
}
@@ -8353,11 +8352,11 @@
let index3 = ((dart.notNull(left) + dart.notNull(right)) / 2)[dartx.truncate]();
let index2 = index3 - sixth;
let index4 = index3 + sixth;
- let el1 = a[dartx.get](index1);
- let el2 = a[dartx.get](index2);
- let el3 = a[dartx.get](index3);
- let el4 = a[dartx.get](index4);
- let el5 = a[dartx.get](index5);
+ let el1 = a[dartx._get](index1);
+ let el2 = a[dartx._get](index2);
+ let el3 = a[dartx._get](index3);
+ let el4 = a[dartx._get](index4);
+ let el5 = a[dartx._get](index5);
if (dart.notNull(compare(el1, el2)) > 0) {
let t = el1;
el1 = el2;
@@ -8405,40 +8404,40 @@
}
let pivot1 = el2;
let pivot2 = el4;
- a[dartx.set](index1, el1);
- a[dartx.set](index3, el3);
- a[dartx.set](index5, el5);
- a[dartx.set](index2, a[dartx.get](left));
- a[dartx.set](index4, a[dartx.get](right));
+ a[dartx._set](index1, el1);
+ a[dartx._set](index3, el3);
+ a[dartx._set](index5, el5);
+ a[dartx._set](index2, a[dartx._get](left));
+ a[dartx._set](index4, a[dartx._get](right));
let less = dart.notNull(left) + 1;
let great = dart.notNull(right) - 1;
let pivots_are_equal = compare(pivot1, pivot2) == 0;
if (pivots_are_equal) {
let pivot = pivot1;
for (let k = less; k <= great; k++) {
- let ak = a[dartx.get](k);
+ let ak = a[dartx._get](k);
let comp = compare(ak, pivot);
if (comp == 0) continue;
if (dart.notNull(comp) < 0) {
if (k != less) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less, ak);
}
less++;
} else {
while (true) {
- comp = compare(a[dartx.get](great), pivot);
+ comp = compare(a[dartx._get](great), pivot);
if (dart.notNull(comp) > 0) {
great--;
continue;
} else if (dart.notNull(comp) < 0) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less++, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less++, a[dartx._get](great));
+ a[dartx._set](great--, ak);
break;
} else {
- a[dartx.set](k, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](great));
+ a[dartx._set](great--, ak);
break;
}
}
@@ -8446,32 +8445,32 @@
}
} else {
for (let k = less; k <= great; k++) {
- let ak = a[dartx.get](k);
+ let ak = a[dartx._get](k);
let comp_pivot1 = compare(ak, pivot1);
if (dart.notNull(comp_pivot1) < 0) {
if (k != less) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less, ak);
}
less++;
} else {
let comp_pivot2 = compare(ak, pivot2);
if (dart.notNull(comp_pivot2) > 0) {
while (true) {
- let comp = compare(a[dartx.get](great), pivot2);
+ let comp = compare(a[dartx._get](great), pivot2);
if (dart.notNull(comp) > 0) {
great--;
if (great < k) break;
continue;
} else {
- comp = compare(a[dartx.get](great), pivot1);
+ comp = compare(a[dartx._get](great), pivot1);
if (dart.notNull(comp) < 0) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less++, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less++, a[dartx._get](great));
+ a[dartx._set](great--, ak);
} else {
- a[dartx.set](k, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](great));
+ a[dartx._set](great--, ak);
}
break;
}
@@ -8480,49 +8479,49 @@
}
}
}
- a[dartx.set](left, a[dartx.get](less - 1));
- a[dartx.set](less - 1, pivot1);
- a[dartx.set](right, a[dartx.get](great + 1));
- a[dartx.set](great + 1, pivot2);
+ a[dartx._set](left, a[dartx._get](less - 1));
+ a[dartx._set](less - 1, pivot1);
+ a[dartx._set](right, a[dartx._get](great + 1));
+ a[dartx._set](great + 1, pivot2);
_internal.Sort._doSort(E)(a, left, less - 2, compare);
_internal.Sort._doSort(E)(a, great + 2, right, compare);
if (pivots_are_equal) {
return;
}
if (less < index1 && great > index5) {
- while (compare(a[dartx.get](less), pivot1) == 0) {
+ while (compare(a[dartx._get](less), pivot1) == 0) {
less++;
}
- while (compare(a[dartx.get](great), pivot2) == 0) {
+ while (compare(a[dartx._get](great), pivot2) == 0) {
great--;
}
for (let k = less; k <= great; k++) {
- let ak = a[dartx.get](k);
+ let ak = a[dartx._get](k);
let comp_pivot1 = compare(ak, pivot1);
if (comp_pivot1 == 0) {
if (k != less) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less, ak);
}
less++;
} else {
let comp_pivot2 = compare(ak, pivot2);
if (comp_pivot2 == 0) {
while (true) {
- let comp = compare(a[dartx.get](great), pivot2);
+ let comp = compare(a[dartx._get](great), pivot2);
if (comp == 0) {
great--;
if (great < k) break;
continue;
} else {
- comp = compare(a[dartx.get](great), pivot1);
+ comp = compare(a[dartx._get](great), pivot1);
if (dart.notNull(comp) < 0) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less++, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less++, a[dartx._get](great));
+ a[dartx._set](great--, ak);
} else {
- a[dartx.set](k, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](great));
+ a[dartx._set](great--, ak);
}
break;
}
@@ -8897,8 +8896,8 @@
return;
}
let message = core.List.new(2);
- message[dartx.set](0, dart.toString(error));
- message[dartx.set](1, stackTrace == null ? null : dart.toString(stackTrace));
+ message[dartx._set](0, dart.toString(error));
+ message[dartx._set](1, stackTrace == null ? null : dart.toString(stackTrace));
for (let port of this.errorPorts)
port.send(message);
}
@@ -8986,13 +8985,13 @@
}
}
lookup(portId) {
- return this.ports[dartx.get](portId);
+ return this.ports[dartx._get](portId);
}
[_addRegistration](portId, port) {
if (dart.test(this.ports[dartx.containsKey](portId))) {
dart.throw(core.Exception.new("Registry: ports must be registered only once."));
}
- this.ports[dartx.set](portId, port);
+ this.ports[dartx._set](portId, port);
}
register(portId, port) {
this[_addRegistration](portId, port);
@@ -9004,7 +9003,7 @@
}
[_updateGlobalState]() {
if (dart.notNull(this.ports[dartx.length]) - dart.notNull(this.weakPorts.length) > 0 || dart.test(this.isPaused) || !dart.test(this.initialized)) {
- _isolate_helper._globalState.isolates[dartx.set](this.id, this);
+ _isolate_helper._globalState.isolates[dartx._set](this.id, this);
} else {
this.kill();
}
@@ -9289,7 +9288,7 @@
}
case 'close':
{
- _isolate_helper._globalState.managers[dartx.remove](_isolate_helper.IsolateNatives.workerIds.get(sender));
+ _isolate_helper._globalState.managers[dartx.remove](_isolate_helper.IsolateNatives.workerIds._get(sender));
sender.terminate();
_isolate_helper._globalState.topEventLoop.run();
break;
@@ -9452,8 +9451,8 @@
let o = _isolate_helper._globalState;
let workerId = o.nextManagerId;
o.nextManagerId = dart.notNull(workerId) + 1;
- _isolate_helper.IsolateNatives.workerIds.set(worker, workerId);
- _isolate_helper._globalState.managers[dartx.set](workerId, worker);
+ _isolate_helper.IsolateNatives.workerIds._set(worker, workerId);
+ _isolate_helper._globalState.managers[dartx._set](workerId, worker);
worker.postMessage(_isolate_helper._serializeMessage(dart.map({command: 'start', id: workerId, replyTo: _isolate_helper._serializeMessage(replyPort), args: args, msg: _isolate_helper._serializeMessage(message), isSpawnUri: isSpawnUri, startPaused: startPaused, functionName: functionName}, core.String, core.Object)));
}
static workerOnError(event, uri, onError) {
@@ -9536,7 +9535,7 @@
super.new(isolateId);
}
send(message) {
- let isolate = _isolate_helper._globalState.isolates[dartx.get](this[_isolateId]);
+ let isolate = _isolate_helper._globalState.isolates[dartx._get](this[_isolateId]);
if (isolate == null) return;
if (dart.test(this[_receivePort][_isClosed])) return;
let msg = _isolate_helper._clone(message);
@@ -9576,7 +9575,7 @@
if (dart.test(_isolate_helper._globalState.isWorker)) {
_isolate_helper._globalState.mainManager.postMessage(workerMessage);
} else {
- let manager = _isolate_helper._globalState.managers[dartx.get](this[_workerId]);
+ let manager = _isolate_helper._globalState.managers[dartx._get](this[_workerId]);
if (manager != null) {
manager.postMessage(workerMessage);
}
@@ -10614,10 +10613,10 @@
}
serialize(x) {
if (dart.test(this.isPrimitive(x))) return this.serializePrimitive(x);
- let serializationId = this.serializedObjectIds[dartx.get](x);
+ let serializationId = this.serializedObjectIds[dartx._get](x);
if (serializationId != null) return this.makeRef(serializationId);
serializationId = this.serializedObjectIds[dartx.length];
- this.serializedObjectIds[dartx.set](x, serializationId);
+ this.serializedObjectIds[dartx._set](x, serializationId);
if (_native_typed_data.NativeByteBuffer.is(x)) return this.serializeByteBuffer(x);
if (_native_typed_data.NativeTypedData.is(x)) return this.serializeTypedData(x);
if (_interceptors.JSIndexable.is(x)) return this.serializeJSIndexable(x);
@@ -10666,13 +10665,13 @@
let serialized = [];
serialized[dartx.length] = x[dartx.length];
for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
- serialized[dartx.set](i, this.serialize(x[dartx.get](i)));
+ serialized[dartx._set](i, this.serialize(x[dartx._get](i)));
}
return serialized;
}
serializeArrayInPlace(x) {
for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
- x[dartx.set](i, this.serialize(x[dartx.get](i)));
+ x[dartx._set](i, this.serialize(x[dartx._get](i)));
}
return x;
}
@@ -10688,7 +10687,7 @@
let values = [];
values[dartx.length] = keys[dartx.length];
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- values[dartx.set](i, this.serialize(x[keys[dartx.get](i)]));
+ values[dartx._set](i, this.serialize(x[keys[dartx._get](i)]));
}
return JSArrayOfObject().of(['js-object', keys, values]);
}
@@ -10827,7 +10826,7 @@
deserializeRef(x) {
dart.assert(dart.equals(dart.dindex(x, 0), 'ref'));
let serializationId = core.int._check(dart.dindex(x, 1));
- return this.deserializedObjects[dartx.get](serializationId);
+ return this.deserializedObjects[dartx._get](serializationId);
}
deserializeByteBuffer(x) {
dart.assert(dart.equals(dart.dindex(x, 0), 'buffer'));
@@ -10843,7 +10842,7 @@
}
deserializeArrayInPlace(x) {
for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
- x[dartx.set](i, this.deserialize(x[dartx.get](i)));
+ x[dartx._set](i, this.deserialize(x[dartx._get](i)));
}
return x;
}
@@ -10872,14 +10871,14 @@
return _interceptors.JSArray.markFixed(this.deserializeArrayInPlace(_interceptors.JSArray._check(result)));
}
deserializeMap(x) {
- dart.assert(dart.equals(x.get(0), 'map'));
- let keys = core.List._check(x.get(1));
- let values = core.List._check(x.get(2));
+ dart.assert(dart.equals(x._get(0), 'map'));
+ let keys = core.List._check(x._get(1));
+ let values = core.List._check(x._get(2));
let result = dart.map();
this.deserializedObjects[dartx.add](result);
keys = keys[dartx.map](dart.dynamic)(dart.bind(this, 'deserialize'))[dartx.toList]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- result[dartx.set](keys[dartx.get](i), this.deserialize(values[dartx.get](i)));
+ result[dartx._set](keys[dartx._get](i), this.deserialize(values[dartx._get](i)));
}
return result;
}
@@ -10890,7 +10889,7 @@
let receivePortId = core.int._check(dart.dindex(x, 3));
let result = null;
if (managerId == _isolate_helper._globalState.currentManagerId) {
- let isolate = _isolate_helper._globalState.isolates[dartx.get](isolateId);
+ let isolate = _isolate_helper._globalState.isolates[dartx._get](isolateId);
if (isolate == null) return null;
let receivePort = isolate.lookup(receivePortId);
if (receivePort == null) return null;
@@ -10914,7 +10913,7 @@
let o = {};
this.deserializedObjects[dartx.add](o);
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- o[keys[dartx.get](i)] = this.deserialize(values[dartx.get](i));
+ o[keys[dartx._get](i)] = this.deserialize(values[dartx._get](i));
}
return o;
}
@@ -11038,12 +11037,12 @@
if (match == null) {
return _js_helper.Primitives._parseIntError(source, handleError);
}
- let decimalMatch = match[dartx.get](decimalIndex);
+ let decimalMatch = match[dartx._get](decimalIndex);
if (radix == null) {
if (decimalMatch != null) {
return parseInt(source, 10);
}
- if (match[dartx.get](hexIndex) != null) {
+ if (match[dartx._get](hexIndex) != null) {
return parseInt(source, 16);
}
return _js_helper.Primitives._parseIntError(source, handleError);
@@ -11064,7 +11063,7 @@
} else {
maxCharCode = 97 - 10 - 1 + dart.notNull(radix);
}
- dart.assert(typeof match[dartx.get](digitsIndex) == 'string');
+ dart.assert(typeof match[dartx._get](digitsIndex) == 'string');
let digitsPart = match[digitsIndex];
for (let i = 0; i < dart.notNull(digitsPart[dartx.length]); i++) {
let characterCode = (dart.notNull(digitsPart[dartx.codeUnitAt](i)) | 32) >>> 0;
@@ -11202,11 +11201,11 @@
static getTimeZoneName(receiver) {
let d = _js_helper.Primitives.lazyAsJsDate(receiver);
let match = /\((.*)\)/.exec(d.toString());
- if (match != null) return core.String._check(match[dartx.get](1));
+ if (match != null) return core.String._check(match[dartx._get](1));
match = /^[A-Z,a-z]{3}\s[A-Z,a-z]{3}\s\d+\s\d{2}:\d{2}:\d{2}\s([A-Z]{3,5})\s\d{4}$/.exec(d.toString());
- if (match != null) return core.String._check(match[dartx.get](1));
+ if (match != null) return core.String._check(match[dartx._get](1));
match = /(?:GMT|UTC)[+-]\d{4}/.exec(d.toString());
- if (match != null) return core.String._check(match[dartx.get](0));
+ if (match != null) return core.String._check(match[dartx._get](0));
return "";
}
static getTimeZoneOffsetInMinutes(receiver) {
@@ -11558,7 +11557,7 @@
while (index < dart.notNull(length)) {
let key = _js_helper.getIndex(keyValuePairs, index++);
let value = _js_helper.getIndex(keyValuePairs, index++);
- result[dartx.set](key, value);
+ result[dartx._set](key, value);
}
return result;
};
@@ -11962,7 +11961,7 @@
return new (LinkedHashMapKeyIterableOfK())(this);
}
get values() {
- return MappedIterableOfK$V().new(this.keys, dart.fn(each => this.get(each), KToV()));
+ return MappedIterableOfK$V().new(this.keys, dart.fn(each => this._get(each), KToV()));
}
containsKey(key) {
if (dart.test(_js_helper.JsLinkedHashMap._isStringKey(key))) {
@@ -11984,15 +11983,15 @@
return dart.notNull(this.internalFindBucketIndex(bucket, key)) >= 0;
}
containsValue(value) {
- return this.keys[dartx.any](dart.fn(each => dart.equals(this.get(each), value), KTobool()));
+ return this.keys[dartx.any](dart.fn(each => dart.equals(this._get(each), value), KTobool()));
}
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
- get(key) {
+ _get(key) {
if (dart.test(_js_helper.JsLinkedHashMap._isStringKey(key))) {
let strings = this[_strings];
if (strings == null) return null;
@@ -12016,7 +12015,7 @@
let cell = bucket[index];
return cell.hashMapCellValue;
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
if (dart.test(_js_helper.JsLinkedHashMap._isStringKey(key))) {
@@ -12056,9 +12055,9 @@
putIfAbsent(key, ifAbsent) {
K._check(key);
VoidToV()._check(ifAbsent);
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
@@ -12231,9 +12230,9 @@
internalContainsKey: dart.definiteFunctionType(core.bool, [core.Object]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
- get: dart.definiteFunctionType(V, [core.Object]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
internalGet: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
internalSet: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
remove: dart.definiteFunctionType(V, [core.Object]),
@@ -12265,8 +12264,8 @@
'containsKey',
'containsValue',
'addAll',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -12553,7 +12552,7 @@
regexp.lastIndex = start;
let match = regexp.exec(string);
if (match == null) return null;
- if (match[dartx.get](dart.notNull(match[dartx.length]) - 1) != null) return null;
+ if (match[dartx._get](dart.notNull(match[dartx.length]) - 1) != null) return null;
match[dartx.length] = dart.notNull(match[dartx.length]) - 1;
return new _js_helper._MatchImplementation(this, ListOfString()._check(match));
}
@@ -12616,12 +12615,12 @@
return this[_match].index;
}
get end() {
- return dart.notNull(this.start) + dart.notNull(this[_match][dartx.get](0)[dartx.length]);
+ return dart.notNull(this.start) + dart.notNull(this[_match][dartx._get](0)[dartx.length]);
}
group(index) {
- return this[_match][dartx.get](index);
+ return this[_match][dartx._get](index);
}
- get(index) {
+ _get(index) {
return this.group(index);
}
get groupCount() {
@@ -12650,7 +12649,7 @@
}),
methods: () => ({
group: dart.definiteFunctionType(core.String, [core.int]),
- get: dart.definiteFunctionType(core.String, [core.int]),
+ _get: dart.definiteFunctionType(core.String, [core.int]),
groups: dart.definiteFunctionType(core.List$(core.String), [ListOfint()])
})
});
@@ -12752,7 +12751,7 @@
get end() {
return dart.notNull(this.start) + dart.notNull(this.pattern[dartx.length]);
}
- get(g) {
+ _get(g) {
return this.group(g);
}
get groupCount() {
@@ -12785,7 +12784,7 @@
groupCount: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(core.String, [core.int]),
+ _get: dart.definiteFunctionType(core.String, [core.int]),
group: dart.definiteFunctionType(core.String, [core.int]),
groups: dart.definiteFunctionType(core.List$(core.String), [ListOfint()])
})
@@ -12908,7 +12907,7 @@
let length = receiver[dartx.length];
result.write(replacement);
for (let i = 0; i < dart.notNull(length); i++) {
- result.write(receiver[dartx.get](i));
+ result.write(receiver[dartx._get](i));
result.write(replacement);
}
return result.toString();
@@ -12928,7 +12927,7 @@
};
dart.lazyFn(_js_helper.stringReplaceAllUnchecked, () => StringAndPatternAndStringToString());
_js_helper._matchString = function(match) {
- return match.get(0);
+ return match._get(0);
};
dart.lazyFn(_js_helper._matchString, () => MatchToString());
_js_helper._stringIdentity = function(string) {
@@ -12971,7 +12970,7 @@
continue;
}
}
- buffer.write(onNonMatch(receiver[dartx.get](i)));
+ buffer.write(onNonMatch(receiver[dartx._get](i)));
i++;
}
buffer.write(onMatch(new _js_helper.StringMatch(i, receiver, "")));
@@ -13140,7 +13139,7 @@
let privateMembers = Object.getOwnPropertySymbols(data);
for (let member of core.Iterable._check(privateMembers)) {
let name = _js_mirrors._getNameForESSymbol(member);
- map[dartx.set](name, data[member]);
+ map[dartx._set](name, data[member]);
}
return map;
};
@@ -13427,13 +13426,13 @@
let constructors = _js_mirrors._getConstructors(unwrapped);
constructors[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
}, StringAnddynamicTovoid()));
if (dart.test(constructors[dartx.isEmpty])) {
let name = 'new';
let ft = _js_mirrors._defaultConstructorType(_js_mirrors._unwrap(this[_cls]));
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
}
let fields = _js_mirrors._getFields(unwrapped);
fields[dartx.forEach](dart.fn((name, t) => {
@@ -13443,23 +13442,23 @@
metadata = core.List._check(dart.dsend(dart.dsend(t, 'skip', 1), 'toList'));
t = dart.dindex(t, 0);
}
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
}, StringAnddynamicTovoid()));
let methods = _js_mirrors._getMethods(unwrapped);
methods[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let getters = _js_mirrors._getGetters(unwrapped);
getters[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let setters = _js_mirrors._getSetters(unwrapped);
setters[dartx.forEach](dart.fn((name, ft) => {
name = dart.notNull(name) + '=';
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let staticFields = _js_mirrors._getStaticFields(unwrapped);
staticFields[dartx.forEach](dart.fn((name, t) => {
@@ -13469,22 +13468,22 @@
metadata = core.List._check(dart.dsend(dart.dsend(t, 'skip', 1), 'toList'));
t = dart.dindex(t, 0);
}
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
}, StringAnddynamicTovoid()));
let statics = _js_mirrors._getStatics(unwrapped);
statics[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let staticGetters = _js_mirrors._getStaticGetters(unwrapped);
staticGetters[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let staticSetters = _js_mirrors._getStaticSetters(unwrapped);
staticSetters[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
}, StringAnddynamicTovoid()));
this[_declarations] = MapOfSymbol$DeclarationMirror().unmodifiable(this[_declarations]);
}
@@ -13796,16 +13795,16 @@
let opts = core.List._check(dart.dload(ftype, 'optionals'));
let params = ListOfParameterMirror().new(dart.notNull(args[dartx.length]) + dart.notNull(opts[dartx.length]));
for (let i = 0; i < dart.notNull(args[dartx.length]); ++i) {
- let type = args[dartx.get](i);
+ let type = args[dartx._get](i);
let metadata = dart.dindex(dart.dload(ftype, 'metadata'), i);
let param = new _js_mirrors.JsParameterMirror._('', core.Type._check(_js_mirrors._wrap(type)), core.List._check(metadata));
- params[dartx.set](i, param);
+ params[dartx._set](i, param);
}
for (let i = 0; i < dart.notNull(opts[dartx.length]); ++i) {
- let type = opts[dartx.get](i);
+ let type = opts[dartx._get](i);
let metadata = dart.dindex(dart.dload(ftype, 'metadata'), dart.notNull(args[dartx.length]) + i);
let param = new _js_mirrors.JsParameterMirror._('', core.Type._check(_js_mirrors._wrap(type)), core.List._check(metadata));
- params[dartx.set](i + dart.notNull(args[dartx.length]), param);
+ params[dartx._set](i + dart.notNull(args[dartx.length]), param);
}
this[_params] = ListOfParameterMirror().unmodifiable(params);
}
@@ -14639,11 +14638,11 @@
_slowFromList(list) {
this[_storage] = _native_typed_data.NativeFloat32List.new(dart.notNull(list[dartx.length]) * 4);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- let e = list[dartx.get](i);
- this[_storage][dartx.set](i * 4 + 0, e.x);
- this[_storage][dartx.set](i * 4 + 1, e.y);
- this[_storage][dartx.set](i * 4 + 2, e.z);
- this[_storage][dartx.set](i * 4 + 3, e.w);
+ let e = list[dartx._get](i);
+ this[_storage][dartx._set](i * 4 + 0, e.x);
+ this[_storage][dartx._set](i * 4 + 1, e.y);
+ this[_storage][dartx._set](i * 4 + 2, e.z);
+ this[_storage][dartx._set](i * 4 + 3, e.w);
}
}
get runtimeType() {
@@ -14674,20 +14673,20 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this.length);
- let _x = this[_storage][dartx.get](dart.notNull(index) * 4 + 0);
- let _y = this[_storage][dartx.get](dart.notNull(index) * 4 + 1);
- let _z = this[_storage][dartx.get](dart.notNull(index) * 4 + 2);
- let _w = this[_storage][dartx.get](dart.notNull(index) * 4 + 3);
+ let _x = this[_storage][dartx._get](dart.notNull(index) * 4 + 0);
+ let _y = this[_storage][dartx._get](dart.notNull(index) * 4 + 1);
+ let _z = this[_storage][dartx._get](dart.notNull(index) * 4 + 2);
+ let _w = this[_storage][dartx._get](dart.notNull(index) * 4 + 3);
return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this.length);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 0, value.x);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 1, value.y);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 2, value.z);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 3, value.w);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 0, value.x);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 1, value.y);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 2, value.z);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 3, value.w);
return value;
}
sublist(start, end) {
@@ -14715,14 +14714,14 @@
length: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(typed_data.Float32x4, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float32x4]),
+ _get: dart.definiteFunctionType(typed_data.Float32x4, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float32x4]),
sublist: dart.definiteFunctionType(core.List$(typed_data.Float32x4), [core.int], [core.int])
})
});
dart.defineExtensionMembers(_native_typed_data.NativeFloat32x4List, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sublist',
'buffer',
'lengthInBytes',
@@ -15272,11 +15271,11 @@
_slowFromList(list) {
this[_storage] = _native_typed_data.NativeInt32List.new(dart.notNull(list[dartx.length]) * 4);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- let e = list[dartx.get](i);
- this[_storage][dartx.set](i * 4 + 0, e.x);
- this[_storage][dartx.set](i * 4 + 1, e.y);
- this[_storage][dartx.set](i * 4 + 2, e.z);
- this[_storage][dartx.set](i * 4 + 3, e.w);
+ let e = list[dartx._get](i);
+ this[_storage][dartx._set](i * 4 + 0, e.x);
+ this[_storage][dartx._set](i * 4 + 1, e.y);
+ this[_storage][dartx._set](i * 4 + 2, e.z);
+ this[_storage][dartx._set](i * 4 + 3, e.w);
}
}
get runtimeType() {
@@ -15307,20 +15306,20 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this.length);
- let _x = this[_storage][dartx.get](dart.notNull(index) * 4 + 0);
- let _y = this[_storage][dartx.get](dart.notNull(index) * 4 + 1);
- let _z = this[_storage][dartx.get](dart.notNull(index) * 4 + 2);
- let _w = this[_storage][dartx.get](dart.notNull(index) * 4 + 3);
+ let _x = this[_storage][dartx._get](dart.notNull(index) * 4 + 0);
+ let _y = this[_storage][dartx._get](dart.notNull(index) * 4 + 1);
+ let _z = this[_storage][dartx._get](dart.notNull(index) * 4 + 2);
+ let _w = this[_storage][dartx._get](dart.notNull(index) * 4 + 3);
return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this.length);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 0, value.x);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 1, value.y);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 2, value.z);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 3, value.w);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 0, value.x);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 1, value.y);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 2, value.z);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 3, value.w);
return value;
}
sublist(start, end) {
@@ -15348,14 +15347,14 @@
length: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Int32x4]),
+ _get: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Int32x4]),
sublist: dart.definiteFunctionType(core.List$(typed_data.Int32x4), [core.int], [core.int])
})
});
dart.defineExtensionMembers(_native_typed_data.NativeInt32x4List, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sublist',
'buffer',
'lengthInBytes',
@@ -15395,9 +15394,9 @@
_slowFromList(list) {
this[_storage] = _native_typed_data.NativeFloat64List.new(dart.notNull(list[dartx.length]) * 2);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- let e = list[dartx.get](i);
- this[_storage][dartx.set](i * 2 + 0, e.x);
- this[_storage][dartx.set](i * 2 + 1, e.y);
+ let e = list[dartx._get](i);
+ this[_storage][dartx._set](i * 2 + 0, e.x);
+ this[_storage][dartx._set](i * 2 + 1, e.y);
}
}
static fromList(list) {
@@ -15428,16 +15427,16 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this.length);
- let _x = this[_storage][dartx.get](dart.notNull(index) * 2 + 0);
- let _y = this[_storage][dartx.get](dart.notNull(index) * 2 + 1);
+ let _x = this[_storage][dartx._get](dart.notNull(index) * 2 + 0);
+ let _y = this[_storage][dartx._get](dart.notNull(index) * 2 + 1);
return typed_data.Float64x2.new(_x, _y);
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this.length);
- this[_storage][dartx.set](dart.notNull(index) * 2 + 0, value.x);
- this[_storage][dartx.set](dart.notNull(index) * 2 + 1, value.y);
+ this[_storage][dartx._set](dart.notNull(index) * 2 + 0, value.x);
+ this[_storage][dartx._set](dart.notNull(index) * 2 + 1, value.y);
return value;
}
sublist(start, end) {
@@ -15465,14 +15464,14 @@
length: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(typed_data.Float64x2, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float64x2]),
+ _get: dart.definiteFunctionType(typed_data.Float64x2, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float64x2]),
sublist: dart.definiteFunctionType(core.List$(typed_data.Float64x2), [core.int], [core.int])
})
});
dart.defineExtensionMembers(_native_typed_data.NativeFloat64x2List, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sublist',
'buffer',
'lengthInBytes',
@@ -15549,7 +15548,7 @@
if (_interceptors.JSIndexable.is(list)) return list;
let result = core.List.new(list[dartx.length]);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- result[dartx.set](i, list[dartx.get](i));
+ result[dartx._set](i, list[dartx._get](i));
}
return result;
};
@@ -15799,8 +15798,8 @@
});
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'setRange'
]);
_native_typed_data.NativeTypedArrayOfDouble = class NativeTypedArrayOfDouble extends dart.mixin(_native_typed_data.NativeTypedArray, collection.ListMixin$(core.double), _internal.FixedLengthListMixin$(core.double)) {
@@ -15810,11 +15809,11 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
this[index] = value;
return value;
@@ -15831,15 +15830,15 @@
dart.setSignature(_native_typed_data.NativeTypedArrayOfDouble, {
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
- get: dart.definiteFunctionType(core.double, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, core.num]),
+ _get: dart.definiteFunctionType(core.double, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, core.num]),
setRange: dart.definiteFunctionType(dart.void, [core.int, core.int, IterableOfdouble()], [core.int])
})
});
-dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfDouble, ['get', 'set', 'setRange', 'length']);
+dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfDouble, ['_get', '_set', 'setRange', 'length']);
dart.defineExtensionNames([
'length',
- 'set',
+ '_set',
'setRange'
]);
_native_typed_data.NativeTypedArrayOfInt = class NativeTypedArrayOfInt extends dart.mixin(_native_typed_data.NativeTypedArray, collection.ListMixin$(core.int), _internal.FixedLengthListMixin$(core.int)) {
@@ -15849,7 +15848,7 @@
set length(value) {
super.length = value;
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
this[index] = value;
return value;
@@ -15867,11 +15866,11 @@
dart.setSignature(_native_typed_data.NativeTypedArrayOfInt, {
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
- set: dart.definiteFunctionType(dart.void, [core.int, core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, core.int]),
setRange: dart.definiteFunctionType(dart.void, [core.int, core.int, IterableOfint()], [core.int])
})
});
-dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfInt, ['set', 'setRange', 'length']);
+dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfInt, ['_set', 'setRange', 'length']);
dart.defineExtensionNames([
'runtimeType',
'sublist'
@@ -15974,7 +15973,7 @@
dart.registerExtension(dart.global.Float64Array, _native_typed_data.NativeFloat64List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeInt16List = class NativeInt16List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -15991,7 +15990,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Int16List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16019,7 +16018,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeInt16List, [_native_typed_data.NativeByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16032,7 +16031,7 @@
dart.registerExtension(dart.global.Int16Array, _native_typed_data.NativeInt16List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeInt32List = class NativeInt32List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16049,7 +16048,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Int32List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16077,7 +16076,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeInt32List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16090,7 +16089,7 @@
dart.registerExtension(dart.global.Int32Array, _native_typed_data.NativeInt32List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeInt8List = class NativeInt8List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16107,7 +16106,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Int8List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16135,7 +16134,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeInt8List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16148,7 +16147,7 @@
dart.registerExtension(dart.global.Int8Array, _native_typed_data.NativeInt8List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint16List = class NativeUint16List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16165,7 +16164,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Uint16List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16193,7 +16192,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint16List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16206,7 +16205,7 @@
dart.registerExtension(dart.global.Uint16Array, _native_typed_data.NativeUint16List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint32List = class NativeUint32List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16223,7 +16222,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Uint32List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16251,7 +16250,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint32List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16265,7 +16264,7 @@
dart.defineExtensionNames([
'runtimeType',
'length',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint8ClampedList = class NativeUint8ClampedList extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16288,7 +16287,7 @@
set [dartx.length](value) {
super[dartx.length] = value;
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16316,7 +16315,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint8ClampedList, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16331,7 +16330,7 @@
dart.defineExtensionNames([
'runtimeType',
'length',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint8List = class NativeUint8List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16354,7 +16353,7 @@
set [dartx.length](value) {
super[dartx.length] = value;
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16382,7 +16381,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint8List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16395,8 +16394,8 @@
dart.registerExtension(dart.global.Uint8Array, _native_typed_data.NativeUint8List);
_native_typed_data.NativeFloat32x4 = class NativeFloat32x4 extends core.Object {
static _truncate(x) {
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, core.num._check(x));
- return _native_typed_data.NativeFloat32x4._list[dartx.get](0);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, core.num._check(x));
+ return _native_typed_data.NativeFloat32x4._list[dartx._get](0);
}
new(x, y, z, w) {
this.x = core.double._check(_native_typed_data.NativeFloat32x4._truncate(x));
@@ -16415,11 +16414,11 @@
NativeFloat32x4.prototype._truncated.call(this, 0.0, 0.0, 0.0, 0.0);
}
static fromInt32x4Bits(i) {
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](0, i.x);
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](1, i.y);
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](2, i.z);
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](3, i.w);
- return new _native_typed_data.NativeFloat32x4._truncated(_native_typed_data.NativeFloat32x4._list[dartx.get](0), _native_typed_data.NativeFloat32x4._list[dartx.get](1), _native_typed_data.NativeFloat32x4._list[dartx.get](2), _native_typed_data.NativeFloat32x4._list[dartx.get](3));
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](0, i.x);
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](1, i.y);
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](2, i.z);
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](3, i.w);
+ return new _native_typed_data.NativeFloat32x4._truncated(_native_typed_data.NativeFloat32x4._list[dartx._get](0), _native_typed_data.NativeFloat32x4._list[dartx._get](1), _native_typed_data.NativeFloat32x4._list[dartx._get](2), _native_typed_data.NativeFloat32x4._list[dartx._get](3));
}
fromFloat64x2(v) {
NativeFloat32x4.prototype._truncated.call(this, core.double._check(_native_typed_data.NativeFloat32x4._truncate(v.x)), core.double._check(_native_typed_data.NativeFloat32x4._truncate(v.y)), 0.0, 0.0);
@@ -16446,7 +16445,7 @@
let _w = dart.notNull(this.w) + dart.notNull(other.w);
return new _native_typed_data.NativeFloat32x4._doubles(_x, _y, _z, _w);
}
- ['unary-']() {
+ _negate() {
return new _native_typed_data.NativeFloat32x4._truncated(-dart.notNull(this.x), -dart.notNull(this.y), -dart.notNull(this.z), -dart.notNull(this.w));
}
['-'](other) {
@@ -16552,46 +16551,46 @@
get signMask() {
let view = _native_typed_data.NativeFloat32x4._uint32view;
let mx = null, my = null, mz = null, mw = null;
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, this.w);
- mx = (dart.notNull(view[dartx.get](0)) & 2147483648) >>> 31;
- my = (dart.notNull(view[dartx.get](1)) & 2147483648) >>> 30;
- mz = (dart.notNull(view[dartx.get](2)) & 2147483648) >>> 29;
- mw = (dart.notNull(view[dartx.get](3)) & 2147483648) >>> 28;
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, this.w);
+ mx = (dart.notNull(view[dartx._get](0)) & 2147483648) >>> 31;
+ my = (dart.notNull(view[dartx._get](1)) & 2147483648) >>> 30;
+ mz = (dart.notNull(view[dartx._get](2)) & 2147483648) >>> 29;
+ mw = (dart.notNull(view[dartx._get](3)) & 2147483648) >>> 28;
return core.int._check(dart.dsend(dart.dsend(dart.dsend(mx, '|', my), '|', mz), '|', mw));
}
shuffle(mask) {
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- let _z = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ let _z = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
}
shuffleMix(other, mask) {
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, other.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, other.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, other.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, other.w);
- let _z = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, other.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, other.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, other.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, other.w);
+ let _z = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
}
withX(newX) {
@@ -16667,7 +16666,7 @@
getters: () => ({signMask: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
'+': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
- 'unary-': dart.definiteFunctionType(typed_data.Float32x4, []),
+ _negate: dart.definiteFunctionType(typed_data.Float32x4, []),
'-': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
'*': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
'/': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
@@ -16709,8 +16708,8 @@
});
_native_typed_data.NativeInt32x4 = class NativeInt32x4 extends core.Object {
static _truncate(x) {
- _native_typed_data.NativeInt32x4._list[dartx.set](0, core.int._check(x));
- return _native_typed_data.NativeInt32x4._list[dartx.get](0);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, core.int._check(x));
+ return _native_typed_data.NativeInt32x4._list[dartx._get](0);
}
new(x, y, z, w) {
this.x = core.int._check(_native_typed_data.NativeInt32x4._truncate(x));
@@ -16730,12 +16729,12 @@
}
static fromFloat32x4Bits(f) {
let floatList = _native_typed_data.NativeFloat32x4._list;
- floatList[dartx.set](0, f.x);
- floatList[dartx.set](1, f.y);
- floatList[dartx.set](2, f.z);
- floatList[dartx.set](3, f.w);
+ floatList[dartx._set](0, f.x);
+ floatList[dartx._set](1, f.y);
+ floatList[dartx._set](2, f.z);
+ floatList[dartx._set](3, f.w);
let view = _native_typed_data.NativeInt32List._check(floatList[dartx.buffer][dartx.asInt32List]());
- return new _native_typed_data.NativeInt32x4._truncated(view[dartx.get](0), view[dartx.get](1), view[dartx.get](2), view[dartx.get](3));
+ return new _native_typed_data.NativeInt32x4._truncated(view[dartx._get](0), view[dartx._get](1), view[dartx._get](2), view[dartx._get](3));
}
_truncated(x, y, z, w) {
this.x = x;
@@ -16761,7 +16760,7 @@
['-'](other) {
return new _native_typed_data.NativeInt32x4._truncated(this.x - other.x | 0, this.y - other.y | 0, this.z - other.z | 0, this.w - other.w | 0);
}
- ['unary-']() {
+ _negate() {
return new _native_typed_data.NativeInt32x4._truncated(-this.x | 0, -this.y | 0, -this.z | 0, -this.w | 0);
}
get signMask() {
@@ -16775,32 +16774,32 @@
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeInt32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeInt32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeInt32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeInt32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- let _z = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeInt32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeInt32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeInt32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ let _z = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
}
shuffleMix(other, mask) {
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeInt32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeInt32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeInt32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeInt32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- _native_typed_data.NativeInt32x4._list[dartx.set](0, other.x);
- _native_typed_data.NativeInt32x4._list[dartx.set](1, other.y);
- _native_typed_data.NativeInt32x4._list[dartx.set](2, other.z);
- _native_typed_data.NativeInt32x4._list[dartx.set](3, other.w);
- let _z = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeInt32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeInt32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeInt32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, other.x);
+ _native_typed_data.NativeInt32x4._list[dartx._set](1, other.y);
+ _native_typed_data.NativeInt32x4._list[dartx._set](2, other.z);
+ _native_typed_data.NativeInt32x4._list[dartx._set](3, other.w);
+ let _z = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
}
withX(x) {
@@ -16850,31 +16849,31 @@
select(trueValue, falseValue) {
let floatList = _native_typed_data.NativeFloat32x4._list;
let intView = _native_typed_data.NativeFloat32x4._uint32view;
- floatList[dartx.set](0, trueValue.x);
- floatList[dartx.set](1, trueValue.y);
- floatList[dartx.set](2, trueValue.z);
- floatList[dartx.set](3, trueValue.w);
- let stx = intView[dartx.get](0);
- let sty = intView[dartx.get](1);
- let stz = intView[dartx.get](2);
- let stw = intView[dartx.get](3);
- floatList[dartx.set](0, falseValue.x);
- floatList[dartx.set](1, falseValue.y);
- floatList[dartx.set](2, falseValue.z);
- floatList[dartx.set](3, falseValue.w);
- let sfx = intView[dartx.get](0);
- let sfy = intView[dartx.get](1);
- let sfz = intView[dartx.get](2);
- let sfw = intView[dartx.get](3);
+ floatList[dartx._set](0, trueValue.x);
+ floatList[dartx._set](1, trueValue.y);
+ floatList[dartx._set](2, trueValue.z);
+ floatList[dartx._set](3, trueValue.w);
+ let stx = intView[dartx._get](0);
+ let sty = intView[dartx._get](1);
+ let stz = intView[dartx._get](2);
+ let stw = intView[dartx._get](3);
+ floatList[dartx._set](0, falseValue.x);
+ floatList[dartx._set](1, falseValue.y);
+ floatList[dartx._set](2, falseValue.z);
+ floatList[dartx._set](3, falseValue.w);
+ let sfx = intView[dartx._get](0);
+ let sfy = intView[dartx._get](1);
+ let sfz = intView[dartx._get](2);
+ let sfw = intView[dartx._get](3);
let _x = (dart.notNull(this.x) & dart.notNull(stx) | ~dart.notNull(this.x) & dart.notNull(sfx)) >>> 0;
let _y = (dart.notNull(this.y) & dart.notNull(sty) | ~dart.notNull(this.y) & dart.notNull(sfy)) >>> 0;
let _z = (dart.notNull(this.z) & dart.notNull(stz) | ~dart.notNull(this.z) & dart.notNull(sfz)) >>> 0;
let _w = (dart.notNull(this.w) & dart.notNull(stw) | ~dart.notNull(this.w) & dart.notNull(sfw)) >>> 0;
- intView[dartx.set](0, _x);
- intView[dartx.set](1, _y);
- intView[dartx.set](2, _z);
- intView[dartx.set](3, _w);
- return new _native_typed_data.NativeFloat32x4._truncated(floatList[dartx.get](0), floatList[dartx.get](1), floatList[dartx.get](2), floatList[dartx.get](3));
+ intView[dartx._set](0, _x);
+ intView[dartx._set](1, _y);
+ intView[dartx._set](2, _z);
+ intView[dartx._set](3, _w);
+ return new _native_typed_data.NativeFloat32x4._truncated(floatList[dartx._get](0), floatList[dartx._get](1), floatList[dartx._get](2), floatList[dartx._get](3));
}
};
dart.defineNamedConstructor(_native_typed_data.NativeInt32x4, 'bool');
@@ -16906,7 +16905,7 @@
'^': dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4]),
'+': dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4]),
'-': dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4]),
- 'unary-': dart.definiteFunctionType(typed_data.Int32x4, []),
+ _negate: dart.definiteFunctionType(typed_data.Int32x4, []),
shuffle: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
shuffleMix: dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4, core.int]),
withX: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
@@ -16954,7 +16953,7 @@
['+'](other) {
return new _native_typed_data.NativeFloat64x2._doubles(dart.notNull(this.x) + dart.notNull(other.x), dart.notNull(this.y) + dart.notNull(other.y));
}
- ['unary-']() {
+ _negate() {
return new _native_typed_data.NativeFloat64x2._doubles(-dart.notNull(this.x), -dart.notNull(this.y));
}
['-'](other) {
@@ -16987,10 +16986,10 @@
}
get signMask() {
let view = _native_typed_data.NativeFloat64x2._uint32View;
- _native_typed_data.NativeFloat64x2._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat64x2._list[dartx.set](1, this.y);
- let mx = (dart.notNull(view[dartx.get](1)) & 2147483648) >>> 31;
- let my = (dart.notNull(view[dartx.get](3)) & 2147483648) >>> 31;
+ _native_typed_data.NativeFloat64x2._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat64x2._list[dartx._set](1, this.y);
+ let mx = (dart.notNull(view[dartx._get](1)) & 2147483648) >>> 31;
+ let my = (dart.notNull(view[dartx._get](3)) & 2147483648) >>> 31;
return (mx | my << 1) >>> 0;
}
withX(x) {
@@ -17031,7 +17030,7 @@
getters: () => ({signMask: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
'+': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
- 'unary-': dart.definiteFunctionType(typed_data.Float64x2, []),
+ _negate: dart.definiteFunctionType(typed_data.Float64x2, []),
'-': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
'*': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
'/': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
@@ -18398,7 +18397,7 @@
future.then(dart.dynamic)(dart.fn(value => {
remaining--;
if (values != null) {
- values[dartx.set](pos, value);
+ values[dartx._set](pos, value);
if (remaining == 0) {
result[_completeWithValue](values);
}
@@ -22423,13 +22422,13 @@
}
};
}
- get(key) {
- let result = this[_map][dartx.get](key);
+ _get(key) {
+ let result = this[_map][dartx._get](key);
if (result != null || dart.test(this[_map][dartx.containsKey](key))) return result;
if (this.parent != null) {
- let value = this.parent.get(key);
+ let value = this.parent._get(key);
if (value != null) {
- this[_map][dartx.set](key, value);
+ this[_map][dartx._set](key, value);
}
return value;
}
@@ -22577,7 +22576,7 @@
bindCallback: dart.definiteFunctionType(R => [async.ZoneCallback$(R), [dart.functionType(R, [])], {runGuarded: core.bool}]),
bindUnaryCallback: dart.definiteFunctionType((R, T) => [async.ZoneUnaryCallback$(R, T), [dart.functionType(R, [T])], {runGuarded: core.bool}]),
bindBinaryCallback: dart.definiteFunctionType((R, T1, T2) => [async.ZoneBinaryCallback$(R, T1, T2), [dart.functionType(R, [T1, T2])], {runGuarded: core.bool}]),
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
handleUncaughtError: dart.definiteFunctionType(R => [R, [dart.dynamic, core.StackTrace]]),
fork: dart.definiteFunctionType(async.Zone, [], {specification: async.ZoneSpecification, zoneValues: core.Map}),
run: dart.definiteFunctionType(R => [R, [dart.functionType(R, [])]]),
@@ -22859,7 +22858,7 @@
}
};
}
- get(key) {
+ _get(key) {
return null;
}
handleUncaughtError(R) {
@@ -22949,7 +22948,7 @@
bindCallback: dart.definiteFunctionType(R => [async.ZoneCallback$(R), [dart.functionType(R, [])], {runGuarded: core.bool}]),
bindUnaryCallback: dart.definiteFunctionType((R, T) => [async.ZoneUnaryCallback$(R, T), [dart.functionType(R, [T])], {runGuarded: core.bool}]),
bindBinaryCallback: dart.definiteFunctionType((R, T1, T2) => [async.ZoneBinaryCallback$(R, T1, T2), [dart.functionType(R, [T1, T2])], {runGuarded: core.bool}]),
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
handleUncaughtError: dart.definiteFunctionType(R => [R, [dart.dynamic, core.StackTrace]]),
fork: dart.definiteFunctionType(async.Zone, [], {specification: async.ZoneSpecification, zoneValues: core.Map}),
run: dart.definiteFunctionType(R => [R, [dart.functionType(R, [])]]),
@@ -23063,7 +23062,7 @@
return new (_HashMapKeyIterableOfK())(this);
}
get values() {
- return MappedIterableOfK$V().new(this.keys, dart.fn(each => this.get(each), KToV()));
+ return MappedIterableOfK$V().new(this.keys, dart.fn(each => this._get(each), KToV()));
}
containsKey(key) {
if (dart.test(collection._HashMap._isStringKey(key))) {
@@ -23083,15 +23082,15 @@
return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
}
containsValue(value) {
- return this[_computeKeys]()[dartx.any](dart.fn(each => dart.equals(this.get(each), value), KTobool()));
+ return this[_computeKeys]()[dartx.any](dart.fn(each => dart.equals(this._get(each), value), KTobool()));
}
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
- get(key) {
+ _get(key) {
if (dart.test(collection._HashMap._isStringKey(key))) {
let strings = this[_strings];
return V._check(strings == null ? null : collection._HashMap._getTableEntry(strings, key));
@@ -23109,7 +23108,7 @@
let index = this[_findBucketIndex](bucket, key);
return V._check(dart.notNull(index) < 0 ? null : bucket[dart.notNull(index) + 1]);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
if (dart.test(collection._HashMap._isStringKey(key))) {
@@ -23150,9 +23149,9 @@
putIfAbsent(key, ifAbsent) {
K._check(key);
VoidToV()._check(ifAbsent);
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
@@ -23184,7 +23183,7 @@
let keys = this[_computeKeys]();
for (let i = 0, length = keys[dartx.length]; i < dart.notNull(length); i++) {
let key = keys[i];
- action(K._check(key), this.get(key));
+ action(K._check(key), this._get(key));
if (keys !== this[_keys]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -23322,9 +23321,9 @@
[_containsKey]: dart.definiteFunctionType(core.bool, [core.Object]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
- get: dart.definiteFunctionType(V, [core.Object]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
[_get]: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
[_set]: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
remove: dart.definiteFunctionType(V, [core.Object]),
@@ -23353,8 +23352,8 @@
'containsKey',
'containsValue',
'addAll',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -23401,11 +23400,11 @@
this[_validKey] = validKey != null ? validKey : dart.fn(v => K.is(v), ObjectTobool());
super.new();
}
- get(key) {
+ _get(key) {
if (!dart.test(this[_validKey](key))) return null;
return super[_get](key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
super[_set](key, value);
@@ -23442,12 +23441,12 @@
[_validKey]: _PredicateOfObject()
}),
methods: () => ({
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
remove: dart.definiteFunctionType(V, [core.Object])
})
});
- dart.defineExtensionMembers(_CustomHashMap, ['get', 'set', 'containsKey', 'remove']);
+ dart.defineExtensionMembers(_CustomHashMap, ['_get', '_set', 'containsKey', 'remove']);
return _CustomHashMap;
});
collection._CustomHashMap = _CustomHashMap();
@@ -23624,13 +23623,13 @@
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
- get(key) {
+ _get(key) {
return this[_map].get(key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
this[_map].set(key, value);
@@ -23640,13 +23639,13 @@
putIfAbsent(key, ifAbsent) {
K._check(key);
VoidToV()._check(ifAbsent);
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
- let value = this.get(key);
+ let value = this._get(key);
this[_map].delete(key);
this[_modified]();
return value;
@@ -23691,8 +23690,8 @@
}),
methods: () => ({
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
remove: dart.definiteFunctionType(V, [core.Object]),
forEach: dart.definiteFunctionType(dart.void, [KAndVTovoid()]),
@@ -23703,8 +23702,8 @@
'containsKey',
'containsValue',
'addAll',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -23850,11 +23849,11 @@
this[_validKey] = validKey != null ? validKey : dart.fn(v => K.is(v), ObjectTobool());
super.new();
}
- get(key) {
+ _get(key) {
if (!dart.test(this[_validKey](key))) return null;
return super.internalGet(key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
super.internalSet(key, value);
@@ -23889,12 +23888,12 @@
[_validKey]: _PredicateOfObject()
}),
methods: () => ({
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
remove: dart.definiteFunctionType(V, [core.Object])
})
});
- dart.defineExtensionMembers(_LinkedCustomHashMap, ['get', 'set', 'containsKey', 'remove']);
+ dart.defineExtensionMembers(_LinkedCustomHashMap, ['_get', '_set', 'containsKey', 'remove']);
return _LinkedCustomHashMap;
});
collection._LinkedCustomHashMap = _LinkedCustomHashMap();
@@ -23995,7 +23994,7 @@
})() : ListOfE().new(this.length);
let i = 0;
for (let element of this)
- result[dartx.set](i++, element);
+ result[dartx._set](i++, element);
return result;
}
map(T) {
@@ -24331,7 +24330,7 @@
let bucket = this[_getBucket](rest, object);
let index = this[_findBucketIndex](bucket, object);
if (dart.notNull(index) < 0) return null;
- return bucket[dartx.get](index);
+ return bucket[dartx._get](index);
}
add(element) {
E._check(element);
@@ -24757,7 +24756,7 @@
let bucket = this[_getBucket](rest, object);
let index = this[_findBucketIndex](bucket, object);
if (dart.notNull(index) < 0) return null;
- return bucket[dartx.get](index)[_element];
+ return bucket[dartx._get](index)[_element];
}
forEach(action) {
let cell = this[_first];
@@ -25189,7 +25188,7 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
return this[_source][dartx.elementAt](index);
}
}
@@ -25197,9 +25196,9 @@
constructors: () => ({new: dart.definiteFunctionType(collection.UnmodifiableListView$(E), [IterableOfE()])}),
fields: () => ({[_source]: IterableOfE()}),
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
- methods: () => ({get: dart.definiteFunctionType(E, [core.int])})
+ methods: () => ({_get: dart.definiteFunctionType(E, [core.int])})
});
- dart.defineExtensionMembers(UnmodifiableListView, ['get', 'length']);
+ dart.defineExtensionMembers(UnmodifiableListView, ['_get', 'length']);
return UnmodifiableListView;
});
collection.UnmodifiableListView = UnmodifiableListView();
@@ -25268,7 +25267,7 @@
static from(other) {
let result = HashMapOfK$V().new();
other[dartx.forEach](dart.fn((k, v) => {
- result.set(K.as(k), V.as(v));
+ result._set(K.as(k), V.as(v));
}, dynamicAnddynamicTovoid()));
return result;
}
@@ -25638,7 +25637,7 @@
});
collection._isToStringVisiting = function(o) {
for (let i = 0; i < dart.notNull(collection._toStringVisiting[dartx.length]); i++) {
- if (core.identical(o, collection._toStringVisiting[dartx.get](i))) return true;
+ if (core.identical(o, collection._toStringVisiting[dartx._get](i))) return true;
}
return false;
};
@@ -25820,7 +25819,7 @@
static from(other) {
let result = LinkedHashMapOfK$V().new();
other[dartx.forEach](dart.fn((k, v) => {
- result.set(K.as(k), V.as(v));
+ result._set(K.as(k), V.as(v));
}, dynamicAnddynamicTovoid()));
return result;
}
@@ -26187,18 +26186,18 @@
class MapMixin extends core.Object {
forEach(action) {
for (let key of this.keys) {
- action(key, this.get(key));
+ action(key, this._get(key));
}
}
addAll(other) {
MapOfK$V()._check(other);
for (let key of other[dartx.keys]) {
- this.set(key, other[dartx.get](key));
+ this._set(key, other[dartx._get](key));
}
}
containsValue(value) {
for (let key of this.keys) {
- if (dart.equals(this.get(key), value)) return true;
+ if (dart.equals(this._get(key), value)) return true;
}
return false;
}
@@ -26206,9 +26205,9 @@
K._check(key);
VoidToV()._check(ifAbsent);
if (dart.test(this.containsKey(key))) {
- return this.get(key);
+ return this._get(key);
}
- return this.set(key, ifAbsent());
+ return this._set(key, ifAbsent());
}
containsKey(key) {
return this.keys[dartx.contains](key);
@@ -26269,7 +26268,7 @@
let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
let VoidToV = () => (VoidToV = dart.constFn(dart.functionType(V, [])))();
class _UnmodifiableMapMixin extends core.Object {
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
@@ -26295,7 +26294,7 @@
_UnmodifiableMapMixin[dart.implements] = () => [MapOfK$V()];
dart.setSignature(_UnmodifiableMapMixin, {
methods: () => ({
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
clear: dart.definiteFunctionType(dart.void, []),
remove: dart.definiteFunctionType(V, [core.Object]),
@@ -26303,7 +26302,7 @@
})
});
dart.defineExtensionMembers(_UnmodifiableMapMixin, [
- 'set',
+ '_set',
'addAll',
'clear',
'remove',
@@ -26339,13 +26338,13 @@
return this[_map][dartx.isNotEmpty];
}
get first() {
- return this[_map][dartx.get](this[_map][dartx.keys][dartx.first]);
+ return this[_map][dartx._get](this[_map][dartx.keys][dartx.first]);
}
get single() {
- return this[_map][dartx.get](this[_map][dartx.keys][dartx.single]);
+ return this[_map][dartx._get](this[_map][dartx.keys][dartx.single]);
}
get last() {
- return this[_map][dartx.get](this[_map][dartx.keys][dartx.last]);
+ return this[_map][dartx._get](this[_map][dartx.keys][dartx.last]);
}
get iterator() {
return new (_MapBaseValueIteratorOfK$V())(this[_map]);
@@ -26386,7 +26385,7 @@
}
moveNext() {
if (dart.test(this[_keys].moveNext())) {
- this[_current] = this[_map][dartx.get](this[_keys].current);
+ this[_current] = this[_map][dartx._get](this[_keys].current);
return true;
}
this[_current] = null;
@@ -26419,13 +26418,13 @@
new(map) {
this[_map] = map;
}
- get(key) {
- return this[_map][dartx.get](key);
+ _get(key) {
+ return this[_map][dartx._get](key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
- this[_map][dartx.set](key, value);
+ this[_map][dartx._set](key, value);
return value;
}
addAll(other) {
@@ -26484,8 +26483,8 @@
values: dart.definiteFunctionType(core.Iterable$(V), [])
}),
methods: () => ({
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
clear: dart.definiteFunctionType(dart.void, []),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
@@ -26496,8 +26495,8 @@
})
});
dart.defineExtensionMembers(MapView, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'addAll',
'clear',
'putIfAbsent',
@@ -26542,10 +26541,10 @@
}
static putIfAbsent(map, key, ifAbsent) {
if (dart.test(map[dartx.containsKey](key))) {
- return map[dartx.get](key);
+ return map[dartx._get](key);
}
let v = ifAbsent();
- map[dartx.set](key, v);
+ map[dartx._set](key, v);
return v;
}
static clear(map) {
@@ -26555,11 +26554,11 @@
}
static forEach(map, f) {
for (let k of map[dartx.keys]) {
- dart.dcall(f, k, map[dartx.get](k));
+ dart.dcall(f, k, map[dartx._get](k));
}
}
static getValues(map) {
- return map[dartx.keys][dartx.map](dart.dynamic)(dart.fn(key => map[dartx.get](key), dynamicTodynamic()));
+ return map[dartx.keys][dartx.map](dart.dynamic)(dart.fn(key => map[dartx._get](key), dynamicTodynamic()));
}
static length(map) {
return map[dartx.keys][dartx.length];
@@ -26602,7 +26601,7 @@
if (key == null) key = collection.Maps._id;
if (value == null) value = collection.Maps._id;
for (let element of iterable) {
- map[dartx.set](dart.dcall(key, element), dart.dcall(value, element));
+ map[dartx._set](dart.dcall(key, element), dart.dcall(value, element));
}
}
static _fillMapWithIterables(map, keys, values) {
@@ -26611,7 +26610,7 @@
let hasNextKey = keyIterator.moveNext();
let hasNextValue = valueIterator.moveNext();
while (dart.test(hasNextKey) && dart.test(hasNextValue)) {
- map[dartx.set](keyIterator.current, valueIterator.current);
+ map[dartx._set](keyIterator.current, valueIterator.current);
hasNextKey = keyIterator.moveNext();
hasNextValue = valueIterator.moveNext();
}
@@ -27150,7 +27149,7 @@
let queue = new (ListQueueOfE())(dart.notNull(length) + 1);
dart.assert(dart.notNull(queue[_table][dartx.length]) > dart.notNull(length));
for (let i = 0; i < dart.notNull(length); i++) {
- queue[_table][dartx.set](i, E.as(elements[dartx.get](i)));
+ queue[_table][dartx._set](i, E.as(elements[dartx._get](i)));
}
queue[_tail] = length;
return queue;
@@ -27172,7 +27171,7 @@
forEach(action) {
let modificationCount = this[_modificationCount];
for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0) {
- action(this[_table][dartx.get](i));
+ action(this[_table][dartx._get](i));
this[_checkModification](modificationCount);
}
}
@@ -27184,20 +27183,20 @@
}
get first() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
- return this[_table][dartx.get](this[_head]);
+ return this[_table][dartx._get](this[_head]);
}
get last() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
- return this[_table][dartx.get]((dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
+ return this[_table][dartx._get]((dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
}
get single() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
if (dart.notNull(this.length) > 1) dart.throw(_internal.IterableElementError.tooMany());
- return this[_table][dartx.get](this[_head]);
+ return this[_table][dartx._get](this[_head]);
}
elementAt(index) {
core.RangeError.checkValidIndex(index, this);
- return this[_table][dartx.get]((dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
+ return this[_table][dartx._get]((dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
}
toList(opts) {
let growable = opts && 'growable' in opts ? opts.growable : true;
@@ -27245,7 +27244,7 @@
}
remove(value) {
for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0) {
- let element = this[_table][dartx.get](i);
+ let element = this[_table][dartx._get](i);
if (dart.equals(element, value)) {
this[_remove](i);
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ -27258,7 +27257,7 @@
let modificationCount = this[_modificationCount];
let i = this[_head];
while (i != this[_tail]) {
- let element = this[_table][dartx.get](i);
+ let element = this[_table][dartx._get](i);
let remove = core.identical(removeMatching, test(element));
this[_checkModification](modificationCount);
if (remove) {
@@ -27278,7 +27277,7 @@
clear() {
if (this[_head] != this[_tail]) {
for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0) {
- this[_table][dartx.set](i, null);
+ this[_table][dartx._set](i, null);
}
this[_head] = this[_tail] = 0;
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ -27294,15 +27293,15 @@
addFirst(value) {
E._check(value);
this[_head] = (dart.notNull(this[_head]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
- this[_table][dartx.set](this[_head], value);
+ this[_table][dartx._set](this[_head], value);
if (this[_head] == this[_tail]) this[_grow]();
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
}
removeFirst() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
- let result = this[_table][dartx.get](this[_head]);
- this[_table][dartx.set](this[_head], null);
+ let result = this[_table][dartx._get](this[_head]);
+ this[_table][dartx._set](this[_head], null);
this[_head] = (dart.notNull(this[_head]) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
return result;
}
@@ -27310,8 +27309,8 @@
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
this[_tail] = (dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
- let result = this[_table][dartx.get](this[_tail]);
- this[_table][dartx.set](this[_tail], null);
+ let result = this[_table][dartx._get](this[_tail]);
+ this[_table][dartx._set](this[_tail], null);
return result;
}
static _isPowerOf2(number) {
@@ -27333,7 +27332,7 @@
}
[_add](element) {
E._check(element);
- this[_table][dartx.set](this[_tail], element);
+ this[_table][dartx._set](this[_tail], element);
this[_tail] = (dart.notNull(this[_tail]) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
if (this[_head] == this[_tail]) this[_grow]();
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ -27346,10 +27345,10 @@
let i = offset;
while (i != this[_head]) {
let prevOffset = (dart.notNull(i) - 1 & mask) >>> 0;
- this[_table][dartx.set](i, this[_table][dartx.get](prevOffset));
+ this[_table][dartx._set](i, this[_table][dartx._get](prevOffset));
i = prevOffset;
}
- this[_table][dartx.set](this[_head], null);
+ this[_table][dartx._set](this[_head], null);
this[_head] = (dart.notNull(this[_head]) + 1 & mask) >>> 0;
return (dart.notNull(offset) + 1 & mask) >>> 0;
} else {
@@ -27357,10 +27356,10 @@
let i = offset;
while (i != this[_tail]) {
let nextOffset = (dart.notNull(i) + 1 & mask) >>> 0;
- this[_table][dartx.set](i, this[_table][dartx.get](nextOffset));
+ this[_table][dartx._set](i, this[_table][dartx._get](nextOffset));
i = nextOffset;
}
- this[_table][dartx.set](this[_tail], null);
+ this[_table][dartx._set](this[_tail], null);
return offset;
}
}
@@ -27482,7 +27481,7 @@
this[_current] = null;
return false;
}
- this[_current] = this[_queue][_table][dartx.get](this[_position]);
+ this[_current] = this[_queue][_table][dartx._get](this[_position]);
this[_position] = (dart.notNull(this[_position]) + 1 & dart.notNull(this[_queue][_table][dartx.length]) - 1) >>> 0;
return true;
}
@@ -27757,7 +27756,7 @@
if (isValidKey === void 0) isValidKey = null;
let result = new (SplayTreeMapOfK$V())(compare, isValidKey);
other[dartx.forEach](dart.fn((k, v) => {
- result.set(K.as(k), V.as(v));
+ result._set(K.as(k), V.as(v));
}, dynamicAnddynamicTovoid()));
return result;
}
@@ -27789,7 +27788,7 @@
this[_validKey] = null;
super.new();
}
- get(key) {
+ _get(key) {
if (!dart.test(dart.dcall(this[_validKey], key))) return null;
if (this[_root] != null) {
let comp = this[_splay](K.as(key));
@@ -27805,7 +27804,7 @@
if (mapRoot != null) return mapRoot.value;
return null;
}
- set(key, value) {
+ _set(key, value) {
(() => {
K._check(key);
V._check(value);
@@ -27843,7 +27842,7 @@
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
get isEmpty() {
@@ -27954,9 +27953,9 @@
}),
methods: () => ({
[_compare]: dart.definiteFunctionType(core.int, [K, K]),
- get: dart.definiteFunctionType(V, [core.Object]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
remove: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
forEach: dart.definiteFunctionType(dart.void, [KAndVTovoid()]),
@@ -27970,9 +27969,9 @@
})
});
dart.defineExtensionMembers(SplayTreeMap, [
- 'get',
+ '_get',
'remove',
- 'set',
+ '_set',
'putIfAbsent',
'addAll',
'forEach',
@@ -28447,7 +28446,7 @@
let processed = map[_processed];
let keys = map[_computeKeys]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
+ let key = keys[dartx._get](i);
let revived = dart.dcall(reviver, key, walk(e[key]));
processed[key] = revived;
}
@@ -28484,9 +28483,9 @@
this[_original] = original;
this[_data] = null;
}
- get(key) {
+ _get(key) {
if (dart.test(this[_isUpgraded])) {
- return this[_upgradedMap][dartx.get](key);
+ return this[_upgradedMap][dartx._get](key);
} else if (!(typeof key == 'string')) {
return null;
} else {
@@ -28510,11 +28509,11 @@
}
get values() {
if (dart.test(this[_isUpgraded])) return this[_upgradedMap][dartx.values];
- return MappedIterableOfString$dynamic().new(this[_computeKeys](), dart.fn(each => this.get(each), dynamicTodynamic()));
+ return MappedIterableOfString$dynamic().new(this[_computeKeys](), dart.fn(each => this._get(each), dynamicTodynamic()));
}
- set(key, value) {
+ _set(key, value) {
if (dart.test(this[_isUpgraded])) {
- this[_upgradedMap][dartx.set](key, value);
+ this[_upgradedMap][dartx._set](key, value);
} else if (dart.test(this.containsKey(key))) {
let processed = this[_processed];
convert._JsonMap._setProperty(processed, core.String._check(key), value);
@@ -28523,21 +28522,21 @@
convert._JsonMap._setProperty(original, core.String._check(key), null);
}
} else {
- this[_upgrade]()[dartx.set](key, value);
+ this[_upgrade]()[dartx._set](key, value);
}
return value;
}
addAll(other) {
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, dynamicAnddynamicTovoid()));
}
containsValue(value) {
if (dart.test(this[_isUpgraded])) return this[_upgradedMap][dartx.containsValue](value);
let keys = this[_computeKeys]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
- if (dart.equals(this.get(key), value)) return true;
+ let key = keys[dartx._get](i);
+ if (dart.equals(this._get(key), value)) return true;
}
return false;
}
@@ -28547,9 +28546,9 @@
return convert._JsonMap._hasProperty(this[_original], core.String._check(key));
}
putIfAbsent(key, ifAbsent) {
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
@@ -28571,7 +28570,7 @@
if (dart.test(this[_isUpgraded])) return this[_upgradedMap][dartx.forEach](f);
let keys = this[_computeKeys]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
+ let key = keys[dartx._get](i);
let value = convert._JsonMap._getProperty(this[_processed], key);
if (dart.test(convert._JsonMap._isUnprocessed(value))) {
value = convert._convertJsonToDartLazy(convert._JsonMap._getProperty(this[_original], key));
@@ -28606,8 +28605,8 @@
let result = dart.map();
let keys = this[_computeKeys]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
- result[dartx.set](key, this.get(key));
+ let key = keys[dartx._get](i);
+ result[dartx._set](key, this._get(key));
}
if (dart.test(keys[dartx.isEmpty])) {
keys[dartx.add](null);
@@ -28661,8 +28660,8 @@
[_upgradedMap]: dart.definiteFunctionType(core.Map, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic]),
addAll: dart.definiteFunctionType(dart.void, [core.Map]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
@@ -28685,8 +28684,8 @@
names: ['_hasProperty', '_getProperty', '_setProperty', '_getPropertyNames', '_isUnprocessed', '_newJavaScriptObject']
});
dart.defineExtensionMembers(convert._JsonMap, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'addAll',
'containsValue',
'containsKey',
@@ -28710,7 +28709,7 @@
return this[_parent].length;
}
elementAt(index) {
- return core.String._check(dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.elementAt](index) : this[_parent][_computeKeys]()[dartx.get](index));
+ return core.String._check(dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.elementAt](index) : this[_parent][_computeKeys]()[dartx._get](index));
}
get iterator() {
return dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.iterator] : this[_parent][_computeKeys]()[dartx.iterator];
@@ -28954,7 +28953,7 @@
let result = ListOfE().new(length);
if (length != 0 && fill != null) {
for (let i = 0; i < dart.notNull(result[dartx.length]); i++) {
- result[dartx.set](i, fill);
+ result[dartx._set](i, fill);
}
}
return result;
@@ -28978,7 +28977,7 @@
result = ListOfE().new(length);
}
for (let i = 0; i < dart.notNull(length); i++) {
- result[dartx.set](i, generator(i));
+ result[dartx._set](i, generator(i));
}
return result;
}
@@ -29017,7 +29016,7 @@
static getByName(name) {
if (name == null) return null;
name = name[dartx.toLowerCase]();
- return convert.Encoding._nameToEncoding[dartx.get](name);
+ return convert.Encoding._nameToEncoding[dartx._get](name);
}
};
dart.addSimpleTypeTests(convert.Encoding);
@@ -29128,7 +29127,7 @@
if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) != 0) {
dart.throw(new core.ArgumentError("String contains invalid characters."));
}
- result[dartx.set](i, codeUnit);
+ result[dartx._set](i, codeUnit);
}
return result;
}
@@ -29207,7 +29206,7 @@
core.RangeError.checkValidRange(start, end, byteCount);
if (end == null) end = byteCount;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
if ((dart.notNull(byte) & ~dart.notNull(this[_subsetMask])) != 0) {
if (!dart.test(this[_allowInvalid])) {
dart.throw(new core.FormatException(dart.str`Invalid value in input: ${byte}`));
@@ -29220,7 +29219,7 @@
[_convertInvalid](bytes, start, end) {
let buffer = new core.StringBuffer();
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let value = bytes[dartx.get](i);
+ let value = bytes[dartx._get](i);
if ((dart.notNull(value) & ~dart.notNull(this[_subsetMask])) != 0) value = 65533;
buffer.writeCharCode(value);
}
@@ -29336,7 +29335,7 @@
addSlice(source, start, end, isLast) {
core.RangeError.checkValidRange(start, end, source[dartx.length]);
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- if ((dart.notNull(source[dartx.get](i)) & ~convert._ASCII_MASK) != 0) {
+ if ((dart.notNull(source[dartx._get](i)) & ~convert._ASCII_MASK) != 0) {
if (dart.notNull(i) > dart.notNull(start)) this[_utf8Sink].addSlice(source, start, i, false);
this[_utf8Sink].add(const || (const = dart.constList([239, 191, 189], core.int)));
start = dart.notNull(i) + 1;
@@ -29367,7 +29366,7 @@
}
add(source) {
for (let i = 0; i < dart.notNull(source[dartx.length]); i++) {
- if ((dart.notNull(source[dartx.get](i)) & ~convert._ASCII_MASK) != 0) {
+ if ((dart.notNull(source[dartx._get](i)) & ~convert._ASCII_MASK) != 0) {
dart.throw(new core.FormatException("Source contains non-ASCII bytes."));
}
}
@@ -29508,27 +29507,27 @@
let expectedChars = 3 - dart.notNull(convert._Base64Encoder._stateCount(state));
let byteOr = 0;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
byteOr = (dart.notNull(byteOr) | dart.notNull(byte)) >>> 0;
bits = (dart.notNull(bits) << 8 | dart.notNull(byte)) & 16777215;
expectedChars--;
if (expectedChars == 0) {
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 18 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 12 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 6 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
@@ -29546,53 +29545,53 @@
}
let i = start;
while (dart.notNull(i) < dart.notNull(end)) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) break;
i = dart.notNull(i) + 1;
}
- dart.throw(new core.ArgumentError.value(bytes, dart.str`Not a byte value at index ${i}: 0x${bytes[dartx.get](i)[dartx.toRadixString](16)}`));
+ dart.throw(new core.ArgumentError.value(bytes, dart.str`Not a byte value at index ${i}: 0x${bytes[dartx._get](i)[dartx.toRadixString](16)}`));
}
static writeFinalChunk(alphabet, output, outputIndex, count, bits) {
dart.assert(dart.notNull(count) > 0);
if (count == 1) {
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 2 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) << 4 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), convert._paddingChar);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), convert._paddingChar);
} else {
dart.assert(count == 2);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 10 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 4 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) << 2 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
@@ -29804,23 +29803,23 @@
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
let char = input[dartx.codeUnitAt](i);
charOr = (dart.notNull(charOr) | dart.notNull(char)) >>> 0;
- let code = convert._Base64Decoder._inverseAlphabet[dartx.get]((dart.notNull(char) & asciiMask) >>> 0);
+ let code = convert._Base64Decoder._inverseAlphabet[dartx._get]((dart.notNull(char) & asciiMask) >>> 0);
if (dart.notNull(code) >= 0) {
bits = (bits[dartx['<<']](bitsPerCharacter) | dart.notNull(code)) & 16777215;
count = dart.notNull(count) + 1 & 3;
if (count == 0) {
dart.assert(dart.notNull(outIndex) + 3 <= dart.notNull(output[dartx.length]));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
})(), (bits[dartx['>>']](16) & eightBitMask) >>> 0);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
})(), (bits[dartx['>>']](8) & eightBitMask) >>> 0);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
@@ -29834,12 +29833,12 @@
if ((dart.notNull(bits) & 3) != 0) {
dart.throw(new core.FormatException("Invalid encoding before padding", input, i));
}
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
})(), bits[dartx['>>']](10));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
@@ -29848,7 +29847,7 @@
if ((dart.notNull(bits) & 15) != 0) {
dart.throw(new core.FormatException("Invalid encoding before padding", input, i));
}
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
@@ -30400,7 +30399,7 @@
[_convert](text, start, end) {
let result = null;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let ch = text[dartx.get](i);
+ let ch = text[dartx._get](i);
let replacement = null;
switch (ch) {
case '&':
@@ -30672,14 +30671,14 @@
}
dart.fn(addChunk, Uint8ListAndintAndintTovoid());
convert._JsonUtf8Stringifier.stringify(object, this[_indent], this[_toEncodable], this[_bufferSize], addChunk);
- if (bytes[dartx.length] == 1) return bytes[dartx.get](0);
+ if (bytes[dartx.length] == 1) return bytes[dartx._get](0);
let length = 0;
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- length = dart.notNull(length) + dart.notNull(bytes[dartx.get](i)[dartx.length]);
+ length = dart.notNull(length) + dart.notNull(bytes[dartx._get](i)[dartx.length]);
}
let result = typed_data.Uint8List.new(length);
for (let i = 0, offset = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byteList = bytes[dartx.get](i);
+ let byteList = bytes[dartx._get](i);
let end = offset + dart.notNull(byteList[dartx.length]);
result[dartx.setRange](offset, end, byteList);
offset = end;
@@ -30916,7 +30915,7 @@
}
[_checkCycle](object) {
for (let i = 0; i < dart.notNull(this[_seen][dartx.length]); i++) {
- if (core.identical(object, this[_seen][dartx.get](i))) {
+ if (core.identical(object, this[_seen][dartx._get](i))) {
dart.throw(new convert.JsonCyclicError(object));
}
}
@@ -30977,10 +30976,10 @@
writeList(list) {
this.writeString('[');
if (dart.notNull(list[dartx.length]) > 0) {
- this.writeObject(list[dartx.get](0));
+ this.writeObject(list[dartx._get](0));
for (let i = 1; i < dart.notNull(list[dartx.length]); i++) {
this.writeString(',');
- this.writeObject(list[dartx.get](i));
+ this.writeObject(list[dartx._get](i));
}
}
this.writeString(']');
@@ -30997,8 +30996,8 @@
if (!(typeof key == 'string')) {
allStringKeys = false;
}
- keyValueList[dartx.set](i++, key);
- keyValueList[dartx.set](i++, value);
+ keyValueList[dartx._set](i++, key);
+ keyValueList[dartx._set](i++, value);
}, dynamicAnddynamicTovoid()));
if (!allStringKeys) return false;
this.writeString('{');
@@ -31006,9 +31005,9 @@
for (let i = 0; i < dart.notNull(keyValueList[dartx.length]); i = i + 2) {
this.writeString(separator);
separator = ',"';
- this.writeStringContent(core.String._check(keyValueList[dartx.get](i)));
+ this.writeStringContent(core.String._check(keyValueList[dartx._get](i)));
this.writeString('":');
- this.writeObject(keyValueList[dartx.get](i + 1));
+ this.writeObject(keyValueList[dartx._get](i + 1));
}
this.writeString('}');
return true;
@@ -31074,11 +31073,11 @@
this.writeString('[\n');
this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
this.writeIndentation(this[_indentLevel]);
- this.writeObject(list[dartx.get](0));
+ this.writeObject(list[dartx._get](0));
for (let i = 1; i < dart.notNull(list[dartx.length]); i++) {
this.writeString(',\n');
this.writeIndentation(this[_indentLevel]);
- this.writeObject(list[dartx.get](i));
+ this.writeObject(list[dartx._get](i));
}
this.writeString('\n');
this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
@@ -31098,8 +31097,8 @@
if (!(typeof key == 'string')) {
allStringKeys = false;
}
- keyValueList[dartx.set](i++, key);
- keyValueList[dartx.set](i++, value);
+ keyValueList[dartx._set](i++, key);
+ keyValueList[dartx._set](i++, value);
}, dynamicAnddynamicTovoid()));
if (!allStringKeys) return false;
this.writeString('{\n');
@@ -31110,9 +31109,9 @@
separator = ",\n";
this.writeIndentation(this[_indentLevel]);
this.writeString('"');
- this.writeStringContent(core.String._check(keyValueList[dartx.get](i)));
+ this.writeStringContent(core.String._check(keyValueList[dartx._get](i)));
this.writeString('": ');
- this.writeObject(keyValueList[dartx.get](i + 1));
+ this.writeObject(keyValueList[dartx._get](i + 1));
}
this.writeString('\n');
this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
@@ -31284,7 +31283,7 @@
this.buffer = typed_data.Uint8List.new(this.bufferSize);
this.index = 0;
}
- this.buffer[dartx.set]((() => {
+ this.buffer[dartx._set]((() => {
let x = this.index;
this.index = dart.notNull(x) + 1;
return x;
@@ -31322,7 +31321,7 @@
let indent = this.indent;
let indentLength = indent[dartx.length];
if (indentLength == 1) {
- let char = indent[dartx.get](0);
+ let char = indent[dartx._get](0);
while (dart.notNull(count) > 0) {
this.writeByte(char);
count = dart.notNull(count) - 1;
@@ -31337,7 +31336,7 @@
this.index = end;
} else {
for (let i = 0; i < dart.notNull(indentLength); i++) {
- this.writeByte(indent[dartx.get](i));
+ this.writeByte(indent[dartx._get](i));
}
}
}
@@ -31446,7 +31445,7 @@
static _checkValidLatin1(source, start, end) {
let mask = 0;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- mask = (dart.notNull(mask) | dart.notNull(source[dartx.get](i))) >>> 0;
+ mask = (dart.notNull(mask) | dart.notNull(source[dartx._get](i))) >>> 0;
}
if (dart.notNull(mask) >= 0 && dart.notNull(mask) <= convert._LATIN1_MASK) {
return;
@@ -31455,7 +31454,7 @@
}
static _reportInvalidLatin1(source, start, end) {
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let char = source[dartx.get](i);
+ let char = source[dartx._get](i);
if (dart.notNull(char) < 0 || dart.notNull(char) > convert._LATIN1_MASK) {
dart.throw(new core.FormatException("Source contains non-Latin-1 characters.", source, i));
}
@@ -31485,7 +31484,7 @@
addSlice(source, start, end, isLast) {
core.RangeError.checkValidRange(start, end, source[dartx.length]);
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let char = source[dartx.get](i);
+ let char = source[dartx._get](i);
if (dart.notNull(char) > convert._LATIN1_MASK || dart.notNull(char) < 0) {
if (dart.notNull(i) > dart.notNull(start)) this[_addSliceToSink](source, start, i, false);
this[_addSliceToSink](const || (const = dart.constList([65533], core.int)), 0, 1, false);
@@ -32025,39 +32024,39 @@
let rune = convert._combineSurrogatePair(leadingSurrogate, nextCodeUnit);
dart.assert(dart.notNull(rune) > convert._THREE_BYTE_LIMIT);
dart.assert(dart.notNull(rune) <= convert._FOUR_BYTE_LIMIT);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (240 | rune[dartx['>>']](18)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) >> 12 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) >> 6 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) & 63);
return true;
} else {
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (224 | leadingSurrogate[dartx['>>']](12)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(leadingSurrogate) >> 6 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32074,7 +32073,7 @@
let codeUnit = str[dartx.codeUnitAt](stringIndex);
if (dart.notNull(codeUnit) <= convert._ONE_BYTE_LIMIT) {
if (dart.notNull(this[_bufferIndex]) >= dart.notNull(this[_buffer][dartx.length])) break;
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32090,12 +32089,12 @@
let rune = codeUnit;
if (dart.notNull(rune) <= convert._TWO_BYTE_LIMIT) {
if (dart.notNull(this[_bufferIndex]) + 1 >= dart.notNull(this[_buffer][dartx.length])) break;
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (192 | rune[dartx['>>']](6)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32103,17 +32102,17 @@
} else {
dart.assert(dart.notNull(rune) <= convert._THREE_BYTE_LIMIT);
if (dart.notNull(this[_bufferIndex]) + 2 >= dart.notNull(this[_buffer][dartx.length])) break;
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (224 | rune[dartx['>>']](12)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) >> 6 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32340,7 +32339,7 @@
if (i == endIndex) {
break loop;
}
- let unit = codeUnits[dartx.get](i);
+ let unit = codeUnits[dartx._get](i);
if ((dart.notNull(unit) & 192) != 128) {
expectedUnits = 0;
if (!dart.test(this[_allowMalformed])) {
@@ -32355,7 +32354,7 @@
i = dart.notNull(i) + 1;
}
} while (dart.notNull(expectedUnits) > 0);
- if (dart.notNull(value) <= dart.notNull(convert._Utf8Decoder._LIMITS[dartx.get](dart.notNull(extraUnits) - 1))) {
+ if (dart.notNull(value) <= dart.notNull(convert._Utf8Decoder._LIMITS[dartx._get](dart.notNull(extraUnits) - 1))) {
if (!dart.test(this[_allowMalformed])) {
dart.throw(new core.FormatException(dart.str`Overlong encoding of 0x${value[dartx.toRadixString](16)}`));
}
@@ -32381,7 +32380,7 @@
i = dart.notNull(i) + dart.notNull(oneBytes);
if (i == endIndex) break;
}
- let unit = codeUnits[dartx.get]((() => {
+ let unit = codeUnits[dartx._get]((() => {
let x = i;
i = dart.notNull(x) + 1;
return x;
@@ -32577,23 +32576,23 @@
return result;
}
dart.fn(parseMilliAndMicroseconds, StringToint());
- let years = core.int.parse(match.get(1));
- let month = core.int.parse(match.get(2));
- let day = core.int.parse(match.get(3));
- let hour = parseIntOrZero(match.get(4));
- let minute = parseIntOrZero(match.get(5));
- let second = parseIntOrZero(match.get(6));
+ let years = core.int.parse(match._get(1));
+ let month = core.int.parse(match._get(2));
+ let day = core.int.parse(match._get(3));
+ let hour = parseIntOrZero(match._get(4));
+ let minute = parseIntOrZero(match._get(5));
+ let second = parseIntOrZero(match._get(6));
let addOneMillisecond = false;
- let milliAndMicroseconds = parseMilliAndMicroseconds(match.get(7));
+ let milliAndMicroseconds = parseMilliAndMicroseconds(match._get(7));
let millisecond = (dart.notNull(milliAndMicroseconds) / core.Duration.MICROSECONDS_PER_MILLISECOND)[dartx.truncate]();
let microsecond = dart.asInt(milliAndMicroseconds[dartx.remainder](core.Duration.MICROSECONDS_PER_MILLISECOND));
let isUtc = false;
- if (match.get(8) != null) {
+ if (match._get(8) != null) {
isUtc = true;
- if (match.get(9) != null) {
- let sign = match.get(9) == '-' ? -1 : 1;
- let hourDifference = core.int.parse(match.get(10));
- let minuteDifference = parseIntOrZero(match.get(11));
+ if (match._get(9) != null) {
+ let sign = match._get(9) == '-' ? -1 : 1;
+ let hourDifference = core.int.parse(match._get(10));
+ let minuteDifference = parseIntOrZero(match._get(11));
minuteDifference = dart.notNull(minuteDifference) + 60 * dart.notNull(hourDifference);
minute = dart.notNull(minute) - sign * dart.notNull(minuteDifference);
}
@@ -32963,7 +32962,7 @@
}
dart.fn(twoDigits, intToString());
if (dart.notNull(this.inMicroseconds) < 0) {
- return dart.str`-${this['unary-']()}`;
+ return dart.str`-${this._negate()}`;
}
let twoDigitMinutes = twoDigits(dart.asInt(this.inMinutes[dartx.remainder](core.Duration.MINUTES_PER_HOUR)));
let twoDigitSeconds = twoDigits(dart.asInt(this.inSeconds[dartx.remainder](core.Duration.SECONDS_PER_MINUTE)));
@@ -32976,7 +32975,7 @@
abs() {
return new core.Duration._microseconds(this[_duration][dartx.abs]());
}
- ['unary-']() {
+ _negate() {
return new core.Duration._microseconds(-dart.notNull(this[_duration]));
}
};
@@ -33008,7 +33007,7 @@
'>=': dart.definiteFunctionType(core.bool, [core.Duration]),
compareTo: dart.definiteFunctionType(core.int, [core.Duration]),
abs: dart.definiteFunctionType(core.Duration, []),
- 'unary-': dart.definiteFunctionType(core.Duration, [])
+ _negate: dart.definiteFunctionType(core.Duration, [])
}),
sfields: () => ({
MICROSECONDS_PER_MILLISECOND: core.int,
@@ -33338,7 +33337,7 @@
if (i > 0) {
sb.write(", ");
}
- sb.write(core.Error.safeToString(this[_arguments][dartx.get](i)));
+ sb.write(core.Error.safeToString(this[_arguments][dartx._get](i)));
}
}
if (this[_namedArguments] != null) {
@@ -33361,7 +33360,7 @@
if (i > 0) {
sb.write(", ");
}
- sb.write(this[_existingArgumentNames][dartx.get](i));
+ sb.write(this[_existingArgumentNames][dartx._get](i));
}
let formalParameters = sb.toString();
return "NoSuchMethodError: incorrect number of arguments passed to " + dart.str`method named '${this[_memberName]}'\n` + dart.str`Receiver: ${core.Error.safeToString(this[_receiver])}\n` + dart.str`Tried calling: ${this[_memberName]}(${actualParameters})\n` + dart.str`Found: ${this[_memberName]}(${formalParameters})`;
@@ -33619,11 +33618,11 @@
toString() {
return dart.str`Expando:${this.name}`;
}
- get(object) {
+ _get(object) {
let values = _js_helper.Primitives.getProperty(object, core.Expando._EXPANDO_PROPERTY_NAME);
return T._check(values == null ? null : _js_helper.Primitives.getProperty(values, this[_getKey]()));
}
- set(object, value) {
+ _set(object, value) {
T._check(value);
let values = _js_helper.Primitives.getProperty(object, core.Expando._EXPANDO_PROPERTY_NAME);
if (values == null) {
@@ -33651,8 +33650,8 @@
constructors: () => ({new: dart.definiteFunctionType(core.Expando$(T), [], [core.String])}),
fields: () => ({name: core.String}),
methods: () => ({
- get: dart.definiteFunctionType(T, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.Object, T]),
+ _get: dart.definiteFunctionType(T, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.Object, T]),
[_getKey]: dart.definiteFunctionType(core.String, [])
}),
sfields: () => ({
@@ -33675,7 +33674,7 @@
static _toMangledNames(namedArguments) {
let result = dart.map({}, core.String, dart.dynamic);
namedArguments[dartx.forEach](dart.fn((symbol, value) => {
- result[dartx.set](core._symbolToString(symbol), value);
+ result[dartx._set](core._symbolToString(symbol), value);
}, SymbolAnddynamicTovoid()));
return result;
}
@@ -34153,7 +34152,7 @@
}
get currentAsString() {
if (this[_position] == this[_nextPosition]) return null;
- if (dart.notNull(this[_position]) + 1 == this[_nextPosition]) return this.string[dartx.get](this[_position]);
+ if (dart.notNull(this[_position]) + 1 == this[_nextPosition]) return this.string[dartx._get](this[_position]);
return this.string[dartx.substring](this[_position], this[_nextPosition]);
}
moveNext() {
@@ -34841,7 +34840,7 @@
if (this[_queryParameterLists] == null) {
let queryParameterLists = core.Uri._splitQueryStringAll(this.query);
for (let key of queryParameterLists[dartx.keys]) {
- queryParameterLists[dartx.set](key, ListOfString().unmodifiable(core.Iterable._check(queryParameterLists[dartx.get](key))));
+ queryParameterLists[dartx._set](key, ListOfString().unmodifiable(core.Iterable._check(queryParameterLists[dartx._get](key))));
}
this[_queryParameterLists] = MapOfString$ListOfString().unmodifiable(queryParameterLists);
}
@@ -34877,7 +34876,7 @@
return core.Uri._normalizeRegName(host, start, end);
}
static _isRegNameChar(char) {
- return dart.notNull(char) < 127 && (dart.notNull(core.Uri._regNameTable[dartx.get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
+ return dart.notNull(char) < 127 && (dart.notNull(core.Uri._regNameTable[dartx._get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
}
static _normalizeRegName(host, start, end) {
let buffer = null;
@@ -35072,9 +35071,9 @@
let codeUnits = null;
if (dart.notNull(char) < 128) {
codeUnits = ListOfint().new(3);
- codeUnits[dartx.set](0, core.Uri._PERCENT);
- codeUnits[dartx.set](1, core.Uri._hexDigits[dartx.codeUnitAt](char[dartx['>>']](4)));
- codeUnits[dartx.set](2, core.Uri._hexDigits[dartx.codeUnitAt](dart.notNull(char) & 15));
+ codeUnits[dartx._set](0, core.Uri._PERCENT);
+ codeUnits[dartx._set](1, core.Uri._hexDigits[dartx.codeUnitAt](char[dartx['>>']](4)));
+ codeUnits[dartx._set](2, core.Uri._hexDigits[dartx.codeUnitAt](dart.notNull(char) & 15));
} else {
let flag = 192;
let encodedBytes = 2;
@@ -35090,9 +35089,9 @@
let index = 0;
while (--encodedBytes >= 0) {
let byte = (char[dartx['>>']](6 * encodedBytes) & 63 | flag) >>> 0;
- codeUnits[dartx.set](index, core.Uri._PERCENT);
- codeUnits[dartx.set](index + 1, core.Uri._hexDigits[dartx.codeUnitAt](byte[dartx['>>']](4)));
- codeUnits[dartx.set](index + 2, core.Uri._hexDigits[dartx.codeUnitAt](byte & 15));
+ codeUnits[dartx._set](index, core.Uri._PERCENT);
+ codeUnits[dartx._set](index + 1, core.Uri._hexDigits[dartx.codeUnitAt](byte[dartx['>>']](4)));
+ codeUnits[dartx._set](index + 2, core.Uri._hexDigits[dartx.codeUnitAt](byte & 15));
index = index + 3;
flag = 128;
}
@@ -35105,7 +35104,7 @@
let index = start;
while (dart.notNull(index) < dart.notNull(end)) {
let char = component[dartx.codeUnitAt](index);
- if (dart.notNull(char) < 127 && (dart.notNull(charTable[dartx.get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0) {
+ if (dart.notNull(char) < 127 && (dart.notNull(charTable[dartx._get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0) {
index = dart.notNull(index) + 1;
} else {
let replacement = null;
@@ -35153,10 +35152,10 @@
return dart.toString(buffer);
}
static _isSchemeCharacter(ch) {
- return dart.notNull(ch) < 128 && (dart.notNull(core.Uri._schemeTable[dartx.get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
+ return dart.notNull(ch) < 128 && (dart.notNull(core.Uri._schemeTable[dartx._get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
}
static _isGeneralDelimiter(ch) {
- return dart.notNull(ch) <= core.Uri._RIGHT_BRACKET && (dart.notNull(core.Uri._genDelimitersTable[dartx.get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
+ return dart.notNull(ch) <= core.Uri._RIGHT_BRACKET && (dart.notNull(core.Uri._genDelimitersTable[dartx._get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
}
get isAbsolute() {
return this.scheme != "" && this.fragment == "";
@@ -35233,7 +35232,7 @@
output[dartx.add](segment);
}
}
- if (dart.test(output[dartx.isEmpty]) || output[dartx.length] == 1 && dart.test(output[dartx.get](0)[dartx.isEmpty])) {
+ if (dart.test(output[dartx.isEmpty]) || output[dartx.length] == 1 && dart.test(output[dartx._get](0)[dartx.isEmpty])) {
return "./";
}
if (appendSlash || output[dartx.last] == '..') output[dartx.add]("");
@@ -35363,8 +35362,8 @@
[_toWindowsFilePath]() {
let hasDriveLetter = false;
let segments = this.pathSegments;
- if (dart.notNull(segments[dartx.length]) > 0 && segments[dartx.get](0)[dartx.length] == 2 && segments[dartx.get](0)[dartx.codeUnitAt](1) == core.Uri._COLON) {
- core.Uri._checkWindowsDriveLetter(segments[dartx.get](0)[dartx.codeUnitAt](0), false);
+ if (dart.notNull(segments[dartx.length]) > 0 && segments[dartx._get](0)[dartx.length] == 2 && segments[dartx._get](0)[dartx.codeUnitAt](1) == core.Uri._COLON) {
+ core.Uri._checkWindowsDriveLetter(segments[dartx._get](0)[dartx.codeUnitAt](0), false);
core.Uri._checkWindowsPathReservedCharacters(segments, false, 1);
hasDriveLetter = true;
} else {
@@ -35461,12 +35460,12 @@
let index = element[dartx.indexOf]("=");
if (index == -1) {
if (element != "") {
- map[dartx.set](core.Uri.decodeQueryComponent(element, {encoding: encoding}), "");
+ map[dartx._set](core.Uri.decodeQueryComponent(element, {encoding: encoding}), "");
}
} else if (index != 0) {
let key = element[dartx.substring](0, index);
let value = element[dartx.substring](dart.notNull(index) + 1);
- map[dartx.set](core.Uri.decodeQueryComponent(key, {encoding: encoding}), core.Uri.decodeQueryComponent(value, {encoding: encoding}));
+ map[dartx._set](core.Uri.decodeQueryComponent(key, {encoding: encoding}), core.Uri.decodeQueryComponent(value, {encoding: encoding}));
}
return map;
}, MapOfString$StringAndStringToMapOfString$String()));
@@ -35584,8 +35583,8 @@
} catch (e) {
try {
let last = core.Uri.parseIPv4Address(host[dartx.substring](partStart, end));
- parts[dartx.add]((dart.notNull(last[dartx.get](0)) << 8 | dart.notNull(last[dartx.get](1))) >>> 0);
- parts[dartx.add]((dart.notNull(last[dartx.get](2)) << 8 | dart.notNull(last[dartx.get](3))) >>> 0);
+ parts[dartx.add]((dart.notNull(last[dartx._get](0)) << 8 | dart.notNull(last[dartx._get](1))) >>> 0);
+ parts[dartx.add]((dart.notNull(last[dartx._get](2)) << 8 | dart.notNull(last[dartx._get](3))) >>> 0);
} catch (e) {
error('invalid end of IPv6 address.', partStart);
}
@@ -35602,17 +35601,17 @@
}
let bytes = typed_data.Uint8List.new(16);
for (let i = 0, index = 0; i < dart.notNull(parts[dartx.length]); i++) {
- let value = parts[dartx.get](i);
+ let value = parts[dartx._get](i);
if (value == -1) {
let wildCardLength = 9 - dart.notNull(parts[dartx.length]);
for (let j = 0; j < wildCardLength; j++) {
- bytes[dartx.set](index, 0);
- bytes[dartx.set](index + 1, 0);
+ bytes[dartx._set](index, 0);
+ bytes[dartx._set](index + 1, 0);
index = index + 2;
}
} else {
- bytes[dartx.set](index, value[dartx['>>']](8));
- bytes[dartx.set](index + 1, dart.notNull(value) & 255);
+ bytes[dartx._set](index, value[dartx['>>']](8));
+ bytes[dartx._set](index + 1, dart.notNull(value) & 255);
index = index + 2;
}
}
@@ -35625,16 +35624,16 @@
let result = new core.StringBuffer();
let bytes = encoding.encode(text);
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byte = bytes[dartx.get](i);
- if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx.get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
+ let byte = bytes[dartx._get](i);
+ if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx._get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
result.writeCharCode(byte);
} else if (dart.test(spaceToPlus) && byte == core.Uri._SPACE) {
result.write('+');
} else {
let hexDigits = '0123456789ABCDEF';
result.write('%');
- result.write(hexDigits[dartx.get](dart.notNull(byte) >> 4 & 15));
- result.write(hexDigits[dartx.get](dart.notNull(byte) & 15));
+ result.write(hexDigits[dartx._get](dart.notNull(byte) >> 4 & 15));
+ result.write(hexDigits[dartx._get](dart.notNull(byte) & 15));
}
}
return result.toString();
@@ -35703,7 +35702,7 @@
return core.Uri._LOWER_CASE_A <= lowerCase && lowerCase <= core.Uri._LOWER_CASE_Z;
}
static _isUnreservedChar(char) {
- return dart.notNull(char) < 127 && (dart.notNull(core.Uri._unreservedTable[dartx.get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
+ return dart.notNull(char) < 127 && (dart.notNull(core.Uri._unreservedTable[dartx._get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
}
};
dart.defineNamedConstructor(core.Uri, '_internal');
@@ -35921,7 +35920,7 @@
let indices = JSArrayOfint().of([core.UriData._noScheme]);
let charsetName = null;
let encodingName = null;
- if (parameters != null) charsetName = parameters[dartx.get]("charset");
+ if (parameters != null) charsetName = parameters[dartx._get]("charset");
if (encoding == null) {
if (charsetName != null) {
encoding = convert.Encoding.getByName(charsetName);
@@ -36037,7 +36036,7 @@
if (this[_uriCache] != null) return this[_uriCache];
let path = this[_text];
let query = null;
- let colonIndex = this[_separatorIndices][dartx.get](0);
+ let colonIndex = this[_separatorIndices][dartx._get](0);
let queryIndex = this[_text][dartx.indexOf]('?', dart.notNull(colonIndex) + 1);
let end = null;
if (dart.notNull(queryIndex) >= 0) {
@@ -36049,8 +36048,8 @@
return this[_uriCache];
}
get mimeType() {
- let start = dart.notNull(this[_separatorIndices][dartx.get](0)) + 1;
- let end = this[_separatorIndices][dartx.get](1);
+ let start = dart.notNull(this[_separatorIndices][dartx._get](0)) + 1;
+ let end = this[_separatorIndices][dartx._get](1);
if (start == end) return "text/plain";
return core.Uri._uriDecode(this[_text], start, end, convert.UTF8, false);
}
@@ -36061,10 +36060,10 @@
parameterEnd = parameterEnd - 1;
}
for (let i = parameterStart; i < parameterEnd; i = i + 2) {
- let keyStart = dart.notNull(this[_separatorIndices][dartx.get](i)) + 1;
- let keyEnd = this[_separatorIndices][dartx.get](i + 1);
+ let keyStart = dart.notNull(this[_separatorIndices][dartx._get](i)) + 1;
+ let keyEnd = this[_separatorIndices][dartx._get](i + 1);
if (keyEnd == keyStart + 7 && dart.test(this[_text][dartx.startsWith]("charset", keyStart))) {
- return core.Uri._uriDecode(this[_text], dart.notNull(keyEnd) + 1, this[_separatorIndices][dartx.get](i + 2), convert.UTF8, false);
+ return core.Uri._uriDecode(this[_text], dart.notNull(keyEnd) + 1, this[_separatorIndices][dartx._get](i + 2), convert.UTF8, false);
}
}
return "US-ASCII";
@@ -36099,14 +36098,14 @@
for (let i = start; i < dart.notNull(text[dartx.length]); i++) {
let codeUnit = text[dartx.codeUnitAt](i);
if (codeUnit != percent) {
- result[dartx.set](index++, codeUnit);
+ result[dartx._set](index++, codeUnit);
} else {
if (i + 2 < dart.notNull(text[dartx.length])) {
let digit1 = core.Uri._parseHexDigit(text[dartx.codeUnitAt](i + 1));
let digit2 = core.Uri._parseHexDigit(text[dartx.codeUnitAt](i + 2));
if (dart.notNull(digit1) >= 0 && dart.notNull(digit2) >= 0) {
let byte = dart.notNull(digit1) * 16 + dart.notNull(digit2);
- result[dartx.set](index++, byte);
+ result[dartx._set](index++, byte);
i = i + 2;
continue;
}
@@ -36137,12 +36136,12 @@
get parameters() {
let result = dart.map({}, core.String, core.String);
for (let i = 3; i < dart.notNull(this[_separatorIndices][dartx.length]); i = i + 2) {
- let start = dart.notNull(this[_separatorIndices][dartx.get](i - 2)) + 1;
- let equals = this[_separatorIndices][dartx.get](i - 1);
- let end = this[_separatorIndices][dartx.get](i);
+ let start = dart.notNull(this[_separatorIndices][dartx._get](i - 2)) + 1;
+ let equals = this[_separatorIndices][dartx._get](i - 1);
+ let end = this[_separatorIndices][dartx._get](i);
let key = core.Uri._uriDecode(this[_text], start, equals, convert.UTF8, false);
let value = core.Uri._uriDecode(this[_text], dart.notNull(equals) + 1, end, convert.UTF8, false);
- result[dartx.set](key, value);
+ result[dartx._set](key, value);
}
return result;
}
@@ -36199,9 +36198,9 @@
static _uriEncodeBytes(canonicalTable, bytes, buffer) {
let byteOr = 0;
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
byteOr = (dart.notNull(byteOr) | dart.notNull(byte)) >>> 0;
- if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx.get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
+ if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx._get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
buffer.writeCharCode(byte);
} else {
buffer.writeCharCode(core.Uri._PERCENT);
@@ -36211,7 +36210,7 @@
}
if ((dart.notNull(byteOr) & ~255) != 0) {
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) {
dart.throw(new core.ArgumentError.value(byte, "non-byte value"));
}
@@ -36219,7 +36218,7 @@
}
}
toString() {
- return this[_separatorIndices][dartx.get](0) == core.UriData._noScheme ? dart.str`data:${this[_text]}` : this[_text];
+ return this[_separatorIndices][dartx._get](0) == core.UriData._noScheme ? dart.str`data:${this[_text]}` : this[_text];
}
};
dart.defineNamedConstructor(core.UriData, '_');
@@ -36292,7 +36291,7 @@
static spawn(entryPoint, message, opts) {
let paused = opts && 'paused' in opts ? opts.paused : false;
try {
- return _isolate_helper.IsolateNatives.spawnFunction(entryPoint, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx.get](1)), {pauseCapability: isolate.Capability._check(msg[dartx.get](2)), terminateCapability: isolate.Capability._check(msg[dartx.get](3))}), ListToIsolate()));
+ return _isolate_helper.IsolateNatives.spawnFunction(entryPoint, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx._get](1)), {pauseCapability: isolate.Capability._check(msg[dartx._get](2)), terminateCapability: isolate.Capability._check(msg[dartx._get](3))}), ListToIsolate()));
} catch (e) {
let st = dart.stackTrace(e);
return FutureOfIsolate().error(e, st);
@@ -36306,14 +36305,14 @@
try {
if (core.List.is(args)) {
for (let i = 0; i < dart.notNull(args[dartx.length]); i++) {
- if (!(typeof args[dartx.get](i) == 'string')) {
+ if (!(typeof args[dartx._get](i) == 'string')) {
dart.throw(new core.ArgumentError(dart.str`Args must be a list of Strings ${args}`));
}
}
} else if (args != null) {
dart.throw(new core.ArgumentError(dart.str`Args must be a list of Strings ${args}`));
}
- return _isolate_helper.IsolateNatives.spawnUri(uri, args, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx.get](1)), {pauseCapability: isolate.Capability._check(msg[dartx.get](2)), terminateCapability: isolate.Capability._check(msg[dartx.get](3))}), ListToIsolate()));
+ return _isolate_helper.IsolateNatives.spawnUri(uri, args, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx._get](1)), {pauseCapability: isolate.Capability._check(msg[dartx._get](2)), terminateCapability: isolate.Capability._check(msg[dartx._get](3))}), ListToIsolate()));
} catch (e) {
let st = dart.stackTrace(e);
return FutureOfIsolate().error(e, st);
@@ -36328,34 +36327,34 @@
}
[_pause](resumeCapability) {
let message = core.List.new(3);
- message[dartx.set](0, "pause");
- message[dartx.set](1, this.pauseCapability);
- message[dartx.set](2, resumeCapability);
+ message[dartx._set](0, "pause");
+ message[dartx._set](1, this.pauseCapability);
+ message[dartx._set](2, resumeCapability);
this.controlPort.send(message);
}
resume(resumeCapability) {
let message = core.List.new(2);
- message[dartx.set](0, "resume");
- message[dartx.set](1, resumeCapability);
+ message[dartx._set](0, "resume");
+ message[dartx._set](1, resumeCapability);
this.controlPort.send(message);
}
addOnExitListener(responsePort) {
let message = core.List.new(2);
- message[dartx.set](0, "add-ondone");
- message[dartx.set](1, responsePort);
+ message[dartx._set](0, "add-ondone");
+ message[dartx._set](1, responsePort);
this.controlPort.send(message);
}
removeOnExitListener(responsePort) {
let message = core.List.new(2);
- message[dartx.set](0, "remove-ondone");
- message[dartx.set](1, responsePort);
+ message[dartx._set](0, "remove-ondone");
+ message[dartx._set](1, responsePort);
this.controlPort.send(message);
}
setErrorsFatal(errorsAreFatal) {
let message = core.List.new(3);
- message[dartx.set](0, "set-errors-fatal");
- message[dartx.set](1, this.terminateCapability);
- message[dartx.set](2, errorsAreFatal);
+ message[dartx._set](0, "set-errors-fatal");
+ message[dartx._set](1, this.terminateCapability);
+ message[dartx._set](2, errorsAreFatal);
this.controlPort.send(message);
}
kill(priority) {
@@ -36365,21 +36364,21 @@
ping(responsePort, pingType) {
if (pingType === void 0) pingType = isolate.Isolate.IMMEDIATE;
let message = core.List.new(3);
- message[dartx.set](0, "ping");
- message[dartx.set](1, responsePort);
- message[dartx.set](2, pingType);
+ message[dartx._set](0, "ping");
+ message[dartx._set](1, responsePort);
+ message[dartx._set](2, pingType);
this.controlPort.send(message);
}
addErrorListener(port) {
let message = core.List.new(2);
- message[dartx.set](0, "getErrors");
- message[dartx.set](1, port);
+ message[dartx._set](0, "getErrors");
+ message[dartx._set](1, port);
this.controlPort.send(message);
}
removeErrorListener(port) {
let message = core.List.new(2);
- message[dartx.set](0, "stopErrors");
- message[dartx.set](1, port);
+ message[dartx._set](0, "stopErrors");
+ message[dartx._set](1, port);
this.controlPort.send(message);
}
get errors() {
@@ -36570,18 +36569,18 @@
let _convertedObjects = collection.HashMap.identity();
function _convert(o) {
if (dart.test(_convertedObjects.containsKey(o))) {
- return _convertedObjects.get(o);
+ return _convertedObjects._get(o);
}
if (core.Map.is(o)) {
let convertedMap = {};
- _convertedObjects.set(o, convertedMap);
+ _convertedObjects._set(o, convertedMap);
for (let key of o[dartx.keys]) {
- convertedMap[key] = _convert(o[dartx.get](key));
+ convertedMap[key] = _convert(o[dartx._get](key));
}
return convertedMap;
} else if (core.Iterable.is(o)) {
let convertedList = [];
- _convertedObjects.set(o, convertedList);
+ _convertedObjects._set(o, convertedList);
convertedList[dartx.addAll](o[dartx.map](dart.dynamic)(_convert));
return convertedList;
} else {
@@ -36591,13 +36590,13 @@
dart.fn(_convert, dynamicTodynamic());
return _convert(data);
}
- get(property) {
+ _get(property) {
if (!(typeof property == 'string') && !(typeof property == 'number')) {
dart.throw(new core.ArgumentError("property is not a String or num"));
}
return js._convertToDart(this[_jsObject][property]);
}
- set(property, value) {
+ _set(property, value) {
if (!(typeof property == 'string') && !(typeof property == 'number')) {
dart.throw(new core.ArgumentError("property is not a String or num"));
}
@@ -36656,8 +36655,8 @@
}),
fields: () => ({[_jsObject]: dart.dynamic}),
methods: () => ({
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
- set: dart.definiteFunctionType(dart.dynamic, [core.Object, dart.dynamic]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _set: dart.definiteFunctionType(dart.dynamic, [core.Object, dart.dynamic]),
hasProperty: dart.definiteFunctionType(core.bool, [dart.dynamic]),
deleteProperty: dart.definiteFunctionType(dart.void, [dart.dynamic]),
instanceof: dart.definiteFunctionType(core.bool, [js.JsFunction]),
@@ -36731,18 +36730,18 @@
dart.throw(new core.RangeError.range(end, start, length));
}
}
- get(index) {
+ _get(index) {
if (typeof index == 'number' && index == index[dartx.toInt]()) {
this[_checkIndex](dart.asInt(index));
}
- return E.as(super.get(index));
+ return E.as(super._get(index));
}
- set(index, value) {
+ _set(index, value) {
E._check(value);
if (typeof index == 'number' && index == index[dartx.toInt]()) {
this[_checkIndex](dart.asInt(index));
}
- super.set(index, value);
+ super._set(index, value);
return value;
}
get length() {
@@ -36753,7 +36752,7 @@
dart.throw(new core.StateError('Bad JsArray length'));
}
set length(length) {
- super.set('length', length);
+ super._set('length', length);
}
add(value) {
E._check(value);
@@ -36811,8 +36810,8 @@
methods: () => ({
[_checkIndex]: dart.definiteFunctionType(dart.dynamic, [core.int]),
[_checkInsertIndex]: dart.definiteFunctionType(dart.dynamic, [core.int]),
- get: dart.definiteFunctionType(E, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.Object, E]),
+ _get: dart.definiteFunctionType(E, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.Object, E]),
add: dart.definiteFunctionType(dart.void, [E]),
addAll: dart.definiteFunctionType(dart.void, [IterableOfE()]),
insert: dart.definiteFunctionType(dart.void, [core.int, E]),
@@ -36825,8 +36824,8 @@
names: ['_checkRange']
});
dart.defineExtensionMembers(JsArray, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'add',
'addAll',
'insert',
@@ -36933,7 +36932,7 @@
set _interopCaptureThisExpando(_) {}
});
js.allowInteropCaptureThis = function(f) {
- let ret = js._interopCaptureThisExpando.get(f);
+ let ret = js._interopCaptureThisExpando._get(f);
if (ret == null) {
ret = function() {
let args = [this];
@@ -36942,7 +36941,7 @@
}
return f(...args);
};
- js._interopCaptureThisExpando.set(f, ret);
+ js._interopCaptureThisExpando._set(f, ret);
}
return ret;
};
@@ -36958,18 +36957,18 @@
let _convertedObjects = collection.HashMap.identity();
function _convert(o) {
if (dart.test(_convertedObjects.containsKey(o))) {
- return _convertedObjects.get(o);
+ return _convertedObjects._get(o);
}
if (core.Map.is(o)) {
let convertedMap = {};
- _convertedObjects.set(o, convertedMap);
+ _convertedObjects._set(o, convertedMap);
for (let key of o[dartx.keys]) {
- convertedMap[key] = _convert(o[dartx.get](key));
+ convertedMap[key] = _convert(o[dartx._get](key));
}
return convertedMap;
} else if (core.Iterable.is(o)) {
let convertedList = [];
- _convertedObjects.set(o, convertedList);
+ _convertedObjects._set(o, convertedList);
convertedList[dartx.addAll](o[dartx.map](dart.dynamic)(_convert));
return convertedList;
} else {
@@ -37580,11 +37579,35 @@
'height'
]);
class Rectangle extends math._RectangleBase$(T) {
+ get left() {
+ return this[left$];
+ }
+ set left(value) {
+ super.left = value;
+ }
+ get top() {
+ return this[top$];
+ }
+ set top(value) {
+ super.top = value;
+ }
+ get width() {
+ return this[width$];
+ }
+ set width(value) {
+ super.width = value;
+ }
+ get height() {
+ return this[height$];
+ }
+ set height(value) {
+ super.height = value;
+ }
new(left, top, width, height) {
- this[dartx.left] = left;
- this[dartx.top] = top;
- this[dartx.width] = dart.notNull(width) < 0 ? -dart.notNull(width) * 0 : width;
- this[dartx.height] = dart.notNull(height) < 0 ? -dart.notNull(height) * 0 : height;
+ this[left$] = left;
+ this[top$] = top;
+ this[width$] = dart.notNull(width) < 0 ? -dart.notNull(width) * 0 : width;
+ this[height$] = dart.notNull(height) < 0 ? -dart.notNull(height) * 0 : height;
super.new();
}
static fromPoints(a, b) {
@@ -37595,6 +37618,10 @@
return new (RectangleOfT())(left, top, width, height);
}
}
+ const left$ = Symbol(Rectangle.name + "." + 'left'.toString());
+ const top$ = Symbol(Rectangle.name + "." + 'top'.toString());
+ const width$ = Symbol(Rectangle.name + "." + 'width'.toString());
+ const height$ = Symbol(Rectangle.name + "." + 'height'.toString());
dart.setSignature(Rectangle, {
constructors: () => ({
new: dart.definiteFunctionType(math.Rectangle$(T), [T, T, T, T]),
@@ -37618,9 +37645,21 @@
let RectangleOfT = () => (RectangleOfT = dart.constFn(math.Rectangle$(T)))();
let PointOfT = () => (PointOfT = dart.constFn(math.Point$(T)))();
class MutableRectangle extends math._RectangleBase$(T) {
+ get left() {
+ return this[left$];
+ }
+ set left(value) {
+ this[left$] = value;
+ }
+ get top() {
+ return this[top$];
+ }
+ set top(value) {
+ this[top$] = value;
+ }
new(left, top, width, height) {
- this.left = left;
- this.top = top;
+ this[left$] = left;
+ this[top$] = top;
this[_width] = dart.notNull(width) < 0 ? math._clampToZero(T)(width) : width;
this[_height] = dart.notNull(height) < 0 ? math._clampToZero(T)(height) : height;
super.new();
@@ -37649,6 +37688,8 @@
this[_height] = height;
}
}
+ const left$ = Symbol(MutableRectangle.name + "." + 'left'.toString());
+ const top$ = Symbol(MutableRectangle.name + "." + 'top'.toString());
MutableRectangle[dart.implements] = () => [RectangleOfT()];
dart.setSignature(MutableRectangle, {
constructors: () => ({
@@ -38227,7 +38268,7 @@
if (dart.test(html_common.isJavaScriptDate(object))) return true;
if (core.List.is(object)) {
for (let i = 0; i < dart.notNull(object[dartx.length]); i++) {
- if (dart.test(containsDate(object[dartx.get](i)))) return true;
+ if (dart.test(containsDate(object[dartx._get](i)))) return true;
}
}
return false;
@@ -38446,10 +38487,10 @@
let autoIncrement = opts && 'autoIncrement' in opts ? opts.autoIncrement : null;
let options = dart.map();
if (keyPath != null) {
- options[dartx.set]('keyPath', keyPath);
+ options[dartx._set]('keyPath', keyPath);
}
if (autoIncrement != null) {
- options[dartx.set]('autoIncrement', autoIncrement);
+ options[dartx._set]('autoIncrement', autoIncrement);
}
return this[_createObjectStore](name, options);
}
@@ -39041,10 +39082,10 @@
let multiEntry = opts && 'multiEntry' in opts ? opts.multiEntry : null;
let options = dart.map();
if (unique != null) {
- options[dartx.set]('unique', unique);
+ options[dartx._set]('unique', unique);
}
if (multiEntry != null) {
- options[dartx.set]('multiEntry', multiEntry);
+ options[dartx._set]('multiEntry', multiEntry);
}
return this[_createIndex](name, keyPath, options);
}
@@ -40223,7 +40264,7 @@
let attributes = this[dartx.attributes];
attributes[dartx.clear]();
for (let key of value[dartx.keys]) {
- attributes[dartx.set](key, value[dartx.get](key));
+ attributes[dartx._set](key, value[dartx._get](key));
}
}
get [dartx.children]() {
@@ -40263,7 +40304,7 @@
let data = this[dartx.dataset];
data[dartx.clear]();
for (let key of value[dartx.keys]) {
- data[dartx.set](key, value[dartx.get](key));
+ data[dartx._set](key, value[dartx._get](key));
}
}
[dartx.getNamespacedAttributes](namespace) {
@@ -40412,7 +40453,7 @@
}
case 'afterbegin':
{
- let first = dart.notNull(this[dartx.nodes][dartx.length]) > 0 ? this[dartx.nodes][dartx.get](0) : null;
+ let first = dart.notNull(this[dartx.nodes][dartx.length]) > 0 ? this[dartx.nodes][dartx._get](0) : null;
this[dartx.insertBefore](node, first);
break;
}
@@ -53162,7 +53203,7 @@
'clear',
'item',
'remove',
- 'get',
+ '_get',
'length'
]);
html.DataTransferItemList = class DataTransferItemList extends _interceptors.Interceptor {
@@ -53190,7 +53231,7 @@
[dartx.remove](index) {
return this.remove(index);
}
- [dartx.get](index) {
+ [dartx._get](index) {
return this[index];
}
};
@@ -53204,7 +53245,7 @@
[dartx.clear]: dart.definiteFunctionType(dart.void, []),
[dartx.item]: dart.definiteFunctionType(html.DataTransferItem, [core.int]),
[dartx.remove]: dart.definiteFunctionType(dart.void, [core.int]),
- [dartx.get]: dart.definiteFunctionType(html.DataTransferItem, [core.int])
+ [dartx._get]: dart.definiteFunctionType(html.DataTransferItem, [core.int])
})
});
dart.registerExtension(dart.global.DataTransferItemList, html.DataTransferItemList);
@@ -56035,8 +56076,8 @@
html.ImmutableListMixin = ImmutableListMixin();
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -56051,11 +56092,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.item](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -56084,7 +56125,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__getter__](index) {
return this.__getter__(index);
@@ -56104,8 +56145,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.String, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
[dartx.elementAt]: dart.definiteFunctionType(core.String, [core.int]),
[__getter__]: dart.definiteFunctionType(core.String, [core.int]),
[dartx.item]: dart.definiteFunctionType(core.String, [core.int])
@@ -56146,11 +56187,11 @@
get length() {
return this[_childElements][dartx.length];
}
- get(index) {
- return html.Element._check(this[_childElements][dartx.get](index));
+ _get(index) {
+ return html.Element._check(this[_childElements][dartx._get](index));
}
- set(index, value) {
- this[_element][_replaceChild](value, this[_childElements][dartx.get](index));
+ _set(index, value) {
+ this[_element][_replaceChild](value, this[_childElements][dartx._get](index));
return value;
}
set length(newLength) {
@@ -56223,7 +56264,7 @@
if (index == this.length) {
this[_element][dartx.append](element);
} else {
- this[_element][dartx.insertBefore](element, this.get(index));
+ this[_element][dartx.insertBefore](element, this._get(index));
}
}
setAll(index, iterable) {
@@ -56233,7 +56274,7 @@
this[_element][_clearChildren]();
}
removeAt(index) {
- let result = this.get(index);
+ let result = this._get(index);
if (result != null) {
this[_element][_removeChild](result);
}
@@ -56283,8 +56324,8 @@
}),
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- get: dart.definiteFunctionType(html.Element, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, html.Element]),
+ _get: dart.definiteFunctionType(html.Element, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, html.Element]),
add: dart.definiteFunctionType(html.Element, [html.Element]),
addAll: dart.definiteFunctionType(dart.void, [IterableOfElement()]),
sort: dart.definiteFunctionType(dart.void, [], [ElementAndElementToint()]),
@@ -56302,8 +56343,8 @@
});
dart.defineExtensionMembers(html._ChildrenElementList, [
'contains',
- 'get',
- 'set',
+ '_get',
+ '_set',
'add',
'addAll',
'sort',
@@ -56345,10 +56386,10 @@
get length() {
return this[_nodeList][dartx.length];
}
- get(index) {
- return html._downcast(html.Node, E)(this[_nodeList][dartx.get](index));
+ _get(index) {
+ return html._downcast(html.Node, E)(this[_nodeList][dartx._get](index));
}
- set(index, value) {
+ _set(index, value) {
E._check(value);
dart.throw(new core.UnsupportedError('Cannot modify list'));
return value;
@@ -56697,14 +56738,14 @@
classes: dart.definiteFunctionType(dart.void, [IterableOfString()])
}),
methods: () => ({
- get: dart.definiteFunctionType(E, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _get: dart.definiteFunctionType(E, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
sort: dart.definiteFunctionType(dart.void, [], [ComparatorOfE()])
})
});
dart.defineExtensionMembers(_FrozenElementList, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sort',
'shuffle',
'length',
@@ -57010,23 +57051,23 @@
new(ptr) {
this[_ptr] = ptr;
}
- get(type) {
+ _get(type) {
return new (_EventStreamOfEvent())(this[_ptr], type, false);
}
};
dart.setSignature(html.Events, {
constructors: () => ({new: dart.definiteFunctionType(html.Events, [html.EventTarget])}),
fields: () => ({[_ptr]: html.EventTarget}),
- methods: () => ({get: dart.definiteFunctionType(async.Stream, [core.String])})
+ methods: () => ({_get: dart.definiteFunctionType(async.Stream, [core.String])})
});
html.ElementEvents = class ElementEvents extends html.Events {
new(ptr) {
super.new(ptr);
}
- get(type) {
+ _get(type) {
if (dart.test(html.ElementEvents.webkitEvents[dartx.keys][dartx.contains](type[dartx.toLowerCase]()))) {
if (dart.test(html_common.Device.isWebKit)) {
- return new (_ElementEventStreamImplOfEvent())(this[_ptr], html.ElementEvents.webkitEvents[dartx.get](type[dartx.toLowerCase]()), false);
+ return new (_ElementEventStreamImplOfEvent())(this[_ptr], html.ElementEvents.webkitEvents[dartx._get](type[dartx.toLowerCase]()), false);
}
}
return new (_ElementEventStreamImplOfEvent())(this[_ptr], type, false);
@@ -57409,8 +57450,8 @@
dart.registerExtension(dart.global.FileError, html.FileError);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -57425,11 +57466,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -57458,7 +57499,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -57475,8 +57516,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.File, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.File]),
+ [dartx._get]: dart.definiteFunctionType(html.File, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.File]),
[dartx.elementAt]: dart.definiteFunctionType(html.File, [core.int]),
[dartx.item]: dart.definiteFunctionType(html.File, [core.int])
})
@@ -58409,13 +58450,13 @@
let maximumAge = opts && 'maximumAge' in opts ? opts.maximumAge : null;
let options = dart.map();
if (enableHighAccuracy != null) {
- options[dartx.set]('enableHighAccuracy', enableHighAccuracy);
+ options[dartx._set]('enableHighAccuracy', enableHighAccuracy);
}
if (timeout != null) {
- options[dartx.set]('timeout', timeout.inMilliseconds);
+ options[dartx._set]('timeout', timeout.inMilliseconds);
}
if (maximumAge != null) {
- options[dartx.set]('maximumAge', maximumAge.inMilliseconds);
+ options[dartx._set]('maximumAge', maximumAge.inMilliseconds);
}
let completer = CompleterOfGeoposition().new();
try {
@@ -58437,13 +58478,13 @@
let maximumAge = opts && 'maximumAge' in opts ? opts.maximumAge : null;
let options = dart.map();
if (enableHighAccuracy != null) {
- options[dartx.set]('enableHighAccuracy', enableHighAccuracy);
+ options[dartx._set]('enableHighAccuracy', enableHighAccuracy);
}
if (timeout != null) {
- options[dartx.set]('timeout', timeout.inMilliseconds);
+ options[dartx._set]('timeout', timeout.inMilliseconds);
}
if (maximumAge != null) {
- options[dartx.set]('maximumAge', maximumAge.inMilliseconds);
+ options[dartx._set]('maximumAge', maximumAge.inMilliseconds);
}
let watchId = null;
let controller = null;
@@ -59483,8 +59524,8 @@
dart.registerExtension(dart.global.HMDVRDevice, html.HmdvrDevice);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -59500,11 +59541,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -59533,7 +59574,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -59553,8 +59594,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.Node, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.Node]),
+ [dartx._get]: dart.definiteFunctionType(html.Node, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.Node]),
[dartx.elementAt]: dart.definiteFunctionType(html.Node, [core.int]),
[dartx.item]: dart.definiteFunctionType(html.Node, [core.int]),
[dartx.namedItem]: dart.definiteFunctionType(core.Object, [core.String])
@@ -59988,9 +60029,9 @@
let key = header[dartx.substring](0, splitIdx)[dartx.toLowerCase]();
let value = header[dartx.substring](dart.notNull(splitIdx) + 2);
if (dart.test(headers[dartx.containsKey](key))) {
- headers[dartx.set](key, dart.str`${headers[dartx.get](key)}, ${value}`);
+ headers[dartx._set](key, dart.str`${headers[dartx._get](key)}, ${value}`);
} else {
- headers[dartx.set](key, value);
+ headers[dartx._set](key, value);
}
}
return headers;
@@ -61046,14 +61087,56 @@
]);
html.InputElementBase = class InputElementBase extends core.Object {
new() {
- this[dartx.autofocus] = null;
- this[dartx.disabled] = null;
- this[dartx.incremental] = null;
- this[dartx.indeterminate] = null;
- this[dartx.name] = null;
- this[dartx.value] = null;
+ this[autofocus] = null;
+ this[disabled] = null;
+ this[incremental] = null;
+ this[indeterminate] = null;
+ this[name] = null;
+ this[value] = null;
+ }
+ get autofocus() {
+ return this[autofocus];
+ }
+ set autofocus(value) {
+ this[autofocus] = value;
+ }
+ get disabled() {
+ return this[disabled];
+ }
+ set disabled(value) {
+ this[disabled] = value;
+ }
+ get incremental() {
+ return this[incremental];
+ }
+ set incremental(value) {
+ this[incremental] = value;
+ }
+ get indeterminate() {
+ return this[indeterminate];
+ }
+ set indeterminate(value) {
+ this[indeterminate] = value;
+ }
+ get name() {
+ return this[name];
+ }
+ set name(value) {
+ this[name] = value;
+ }
+ get value() {
+ return this[value];
+ }
+ set value(value) {
+ this[value] = value;
}
};
+const autofocus = Symbol(html.InputElementBase.name + "." + 'autofocus'.toString());
+const disabled = Symbol(html.InputElementBase.name + "." + 'disabled'.toString());
+const incremental = Symbol(html.InputElementBase.name + "." + 'incremental'.toString());
+const indeterminate = Symbol(html.InputElementBase.name + "." + 'indeterminate'.toString());
+const name = Symbol(html.InputElementBase.name + "." + 'name'.toString());
+const value = Symbol(html.InputElementBase.name + "." + 'value'.toString());
html.InputElementBase[dart.implements] = () => [html.Element];
dart.setSignature(html.InputElementBase, {
fields: () => ({
@@ -61102,18 +61185,88 @@
]);
html.TextInputElementBase = class TextInputElementBase extends core.Object {
new() {
- this[dartx.autocomplete] = null;
- this[dartx.maxLength] = null;
- this[dartx.pattern] = null;
- this[dartx.placeholder] = null;
- this[dartx.readOnly] = null;
- this[dartx.required] = null;
- this[dartx.size] = null;
- this[dartx.selectionDirection] = null;
- this[dartx.selectionEnd] = null;
- this[dartx.selectionStart] = null;
+ this[autocomplete] = null;
+ this[maxLength] = null;
+ this[pattern] = null;
+ this[placeholder] = null;
+ this[readOnly] = null;
+ this[required] = null;
+ this[size] = null;
+ this[selectionDirection] = null;
+ this[selectionEnd] = null;
+ this[selectionStart] = null;
+ }
+ get autocomplete() {
+ return this[autocomplete];
+ }
+ set autocomplete(value) {
+ this[autocomplete] = value;
+ }
+ get maxLength() {
+ return this[maxLength];
+ }
+ set maxLength(value) {
+ this[maxLength] = value;
+ }
+ get pattern() {
+ return this[pattern];
+ }
+ set pattern(value) {
+ this[pattern] = value;
+ }
+ get placeholder() {
+ return this[placeholder];
+ }
+ set placeholder(value) {
+ this[placeholder] = value;
+ }
+ get readOnly() {
+ return this[readOnly];
+ }
+ set readOnly(value) {
+ this[readOnly] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
+ get size() {
+ return this[size];
+ }
+ set size(value) {
+ this[size] = value;
+ }
+ get selectionDirection() {
+ return this[selectionDirection];
+ }
+ set selectionDirection(value) {
+ this[selectionDirection] = value;
+ }
+ get selectionEnd() {
+ return this[selectionEnd];
+ }
+ set selectionEnd(value) {
+ this[selectionEnd] = value;
+ }
+ get selectionStart() {
+ return this[selectionStart];
+ }
+ set selectionStart(value) {
+ this[selectionStart] = value;
}
};
+const autocomplete = Symbol(html.TextInputElementBase.name + "." + 'autocomplete'.toString());
+const maxLength = Symbol(html.TextInputElementBase.name + "." + 'maxLength'.toString());
+const pattern = Symbol(html.TextInputElementBase.name + "." + 'pattern'.toString());
+const placeholder = Symbol(html.TextInputElementBase.name + "." + 'placeholder'.toString());
+const readOnly = Symbol(html.TextInputElementBase.name + "." + 'readOnly'.toString());
+const required = Symbol(html.TextInputElementBase.name + "." + 'required'.toString());
+const size = Symbol(html.TextInputElementBase.name + "." + 'size'.toString());
+const selectionDirection = Symbol(html.TextInputElementBase.name + "." + 'selectionDirection'.toString());
+const selectionEnd = Symbol(html.TextInputElementBase.name + "." + 'selectionEnd'.toString());
+const selectionStart = Symbol(html.TextInputElementBase.name + "." + 'selectionStart'.toString());
html.TextInputElementBase[dart.implements] = () => [html.InputElementBase];
dart.setSignature(html.TextInputElementBase, {
fields: () => ({
@@ -61158,10 +61311,17 @@
static new() {
return html.InputElement.new({type: 'search'});
}
+ get dirName() {
+ return this[dirName];
+ }
+ set dirName(value) {
+ this[dirName] = value;
+ }
static get supported() {
return html.InputElement.new({type: 'search'})[dartx.type] == 'search';
}
};
+const dirName = Symbol(html.SearchInputElement.name + "." + 'dirName'.toString());
html.SearchInputElement[dart.implements] = () => [html.TextInputElementBase];
dart.setSignature(html.SearchInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.SearchInputElement, [])}),
@@ -61176,7 +61336,14 @@
static new() {
return html.InputElement.new({type: 'text'});
}
+ get dirName() {
+ return this[dirName];
+ }
+ set dirName(value) {
+ this[dirName] = value;
+ }
};
+const dirName = Symbol(html.TextInputElement.name + "." + 'dirName'.toString());
html.TextInputElement[dart.implements] = () => [html.TextInputElementBase];
dart.setSignature(html.TextInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.TextInputElement, [])}),
@@ -61224,10 +61391,73 @@
static new() {
return html.InputElement.new({type: 'email'});
}
+ get autocomplete() {
+ return this[autocomplete];
+ }
+ set autocomplete(value) {
+ this[autocomplete] = value;
+ }
+ get autofocus() {
+ return this[autofocus];
+ }
+ set autofocus(value) {
+ this[autofocus] = value;
+ }
+ get maxLength() {
+ return this[maxLength];
+ }
+ set maxLength(value) {
+ this[maxLength] = value;
+ }
+ get multiple() {
+ return this[multiple];
+ }
+ set multiple(value) {
+ this[multiple] = value;
+ }
+ get pattern() {
+ return this[pattern];
+ }
+ set pattern(value) {
+ this[pattern] = value;
+ }
+ get placeholder() {
+ return this[placeholder];
+ }
+ set placeholder(value) {
+ this[placeholder] = value;
+ }
+ get readOnly() {
+ return this[readOnly];
+ }
+ set readOnly(value) {
+ this[readOnly] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
+ get size() {
+ return this[size];
+ }
+ set size(value) {
+ this[size] = value;
+ }
static get supported() {
return html.InputElement.new({type: 'email'})[dartx.type] == 'email';
}
};
+const autocomplete = Symbol(html.EmailInputElement.name + "." + 'autocomplete'.toString());
+const autofocus = Symbol(html.EmailInputElement.name + "." + 'autofocus'.toString());
+const maxLength = Symbol(html.EmailInputElement.name + "." + 'maxLength'.toString());
+const multiple = Symbol(html.EmailInputElement.name + "." + 'multiple'.toString());
+const pattern = Symbol(html.EmailInputElement.name + "." + 'pattern'.toString());
+const placeholder = Symbol(html.EmailInputElement.name + "." + 'placeholder'.toString());
+const readOnly = Symbol(html.EmailInputElement.name + "." + 'readOnly'.toString());
+const required = Symbol(html.EmailInputElement.name + "." + 'required'.toString());
+const size = Symbol(html.EmailInputElement.name + "." + 'size'.toString());
html.EmailInputElement[dart.implements] = () => [html.TextInputElementBase];
dart.setSignature(html.EmailInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.EmailInputElement, [])}),
@@ -61281,12 +61511,40 @@
]);
html.RangeInputElementBase = class RangeInputElementBase extends core.Object {
new() {
- this[dartx.max] = null;
- this[dartx.min] = null;
- this[dartx.step] = null;
- this[dartx.valueAsNumber] = null;
+ this[max] = null;
+ this[min] = null;
+ this[step] = null;
+ this[valueAsNumber] = null;
+ }
+ get max() {
+ return this[max];
+ }
+ set max(value) {
+ this[max] = value;
+ }
+ get min() {
+ return this[min];
+ }
+ set min(value) {
+ this[min] = value;
+ }
+ get step() {
+ return this[step];
+ }
+ set step(value) {
+ this[step] = value;
+ }
+ get valueAsNumber() {
+ return this[valueAsNumber];
+ }
+ set valueAsNumber(value) {
+ this[valueAsNumber] = value;
}
};
+const max = Symbol(html.RangeInputElementBase.name + "." + 'max'.toString());
+const min = Symbol(html.RangeInputElementBase.name + "." + 'min'.toString());
+const step = Symbol(html.RangeInputElementBase.name + "." + 'step'.toString());
+const valueAsNumber = Symbol(html.RangeInputElementBase.name + "." + 'valueAsNumber'.toString());
html.RangeInputElementBase[dart.implements] = () => [html.InputElementBase];
dart.setSignature(html.RangeInputElementBase, {
fields: () => ({
@@ -61315,10 +61573,31 @@
static new() {
return html.InputElement.new({type: 'date'});
}
+ get valueAsDate() {
+ return this[valueAsDate];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate] = value;
+ }
+ get readOnly() {
+ return this[readOnly];
+ }
+ set readOnly(value) {
+ this[readOnly] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
static get supported() {
return html.InputElement.new({type: 'date'})[dartx.type] == 'date';
}
};
+const valueAsDate = Symbol(html.DateInputElement.name + "." + 'valueAsDate'.toString());
+const readOnly = Symbol(html.DateInputElement.name + "." + 'readOnly'.toString());
+const required = Symbol(html.DateInputElement.name + "." + 'required'.toString());
html.DateInputElement[dart.implements] = () => [html.RangeInputElementBase];
dart.setSignature(html.DateInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.DateInputElement, [])}),
@@ -61346,10 +61625,31 @@
static new() {
return html.InputElement.new({type: 'month'});
}
+ get valueAsDate() {
+ return this[valueAsDate];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate] = value;
+ }
+ get readOnly() {
+ return this[readOnly];
+ }
+ set readOnly(value) {
+ this[readOnly] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
static get supported() {
return html.InputElement.new({type: 'month'})[dartx.type] == 'month';
}
};
+const valueAsDate = Symbol(html.MonthInputElement.name + "." + 'valueAsDate'.toString());
+const readOnly = Symbol(html.MonthInputElement.name + "." + 'readOnly'.toString());
+const required = Symbol(html.MonthInputElement.name + "." + 'required'.toString());
html.MonthInputElement[dart.implements] = () => [html.RangeInputElementBase];
dart.setSignature(html.MonthInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.MonthInputElement, [])}),
@@ -61377,10 +61677,31 @@
static new() {
return html.InputElement.new({type: 'week'});
}
+ get valueAsDate() {
+ return this[valueAsDate];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate] = value;
+ }
+ get readOnly() {
+ return this[readOnly];
+ }
+ set readOnly(value) {
+ this[readOnly] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
static get supported() {
return html.InputElement.new({type: 'week'})[dartx.type] == 'week';
}
};
+const valueAsDate = Symbol(html.WeekInputElement.name + "." + 'valueAsDate'.toString());
+const readOnly = Symbol(html.WeekInputElement.name + "." + 'readOnly'.toString());
+const required = Symbol(html.WeekInputElement.name + "." + 'required'.toString());
html.WeekInputElement[dart.implements] = () => [html.RangeInputElementBase];
dart.setSignature(html.WeekInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.WeekInputElement, [])}),
@@ -61408,10 +61729,31 @@
static new() {
return html.InputElement.new({type: 'time'});
}
+ get valueAsDate() {
+ return this[valueAsDate];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate] = value;
+ }
+ get readOnly() {
+ return this[readOnly];
+ }
+ set readOnly(value) {
+ this[readOnly] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
static get supported() {
return html.InputElement.new({type: 'time'})[dartx.type] == 'time';
}
};
+const valueAsDate = Symbol(html.TimeInputElement.name + "." + 'valueAsDate'.toString());
+const readOnly = Symbol(html.TimeInputElement.name + "." + 'readOnly'.toString());
+const required = Symbol(html.TimeInputElement.name + "." + 'required'.toString());
html.TimeInputElement[dart.implements] = () => [html.RangeInputElementBase];
dart.setSignature(html.TimeInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.TimeInputElement, [])}),
@@ -61438,10 +61780,24 @@
static new() {
return html.InputElement.new({type: 'datetime-local'});
}
+ get readOnly() {
+ return this[readOnly];
+ }
+ set readOnly(value) {
+ this[readOnly] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
static get supported() {
return html.InputElement.new({type: 'datetime-local'})[dartx.type] == 'datetime-local';
}
};
+const readOnly = Symbol(html.LocalDateTimeInputElement.name + "." + 'readOnly'.toString());
+const required = Symbol(html.LocalDateTimeInputElement.name + "." + 'required'.toString());
html.LocalDateTimeInputElement[dart.implements] = () => [html.RangeInputElementBase];
dart.setSignature(html.LocalDateTimeInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.LocalDateTimeInputElement, [])}),
@@ -61461,10 +61817,31 @@
static new() {
return html.InputElement.new({type: 'number'});
}
+ get placeholder() {
+ return this[placeholder];
+ }
+ set placeholder(value) {
+ this[placeholder] = value;
+ }
+ get readOnly() {
+ return this[readOnly];
+ }
+ set readOnly(value) {
+ this[readOnly] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
static get supported() {
return html.InputElement.new({type: 'number'})[dartx.type] == 'number';
}
};
+const placeholder = Symbol(html.NumberInputElement.name + "." + 'placeholder'.toString());
+const readOnly = Symbol(html.NumberInputElement.name + "." + 'readOnly'.toString());
+const required = Symbol(html.NumberInputElement.name + "." + 'required'.toString());
html.NumberInputElement[dart.implements] = () => [html.RangeInputElementBase];
dart.setSignature(html.NumberInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.NumberInputElement, [])}),
@@ -61504,7 +61881,21 @@
static new() {
return html.InputElement.new({type: 'checkbox'});
}
+ get checked() {
+ return this[checked];
+ }
+ set checked(value) {
+ this[checked] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
};
+const checked = Symbol(html.CheckboxInputElement.name + "." + 'checked'.toString());
+const required = Symbol(html.CheckboxInputElement.name + "." + 'required'.toString());
html.CheckboxInputElement[dart.implements] = () => [html.InputElementBase];
dart.setSignature(html.CheckboxInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.CheckboxInputElement, [])}),
@@ -61522,7 +61913,21 @@
static new() {
return html.InputElement.new({type: 'radio'});
}
+ get checked() {
+ return this[checked];
+ }
+ set checked(value) {
+ this[checked] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
};
+const checked = Symbol(html.RadioButtonInputElement.name + "." + 'checked'.toString());
+const required = Symbol(html.RadioButtonInputElement.name + "." + 'required'.toString());
html.RadioButtonInputElement[dart.implements] = () => [html.InputElementBase];
dart.setSignature(html.RadioButtonInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.RadioButtonInputElement, [])}),
@@ -61542,7 +61947,35 @@
static new() {
return html.InputElement.new({type: 'file'});
}
+ get accept() {
+ return this[accept];
+ }
+ set accept(value) {
+ this[accept] = value;
+ }
+ get multiple() {
+ return this[multiple];
+ }
+ set multiple(value) {
+ this[multiple] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
+ get files() {
+ return this[files];
+ }
+ set files(value) {
+ this[files] = value;
+ }
};
+const accept = Symbol(html.FileUploadInputElement.name + "." + 'accept'.toString());
+const multiple = Symbol(html.FileUploadInputElement.name + "." + 'multiple'.toString());
+const required = Symbol(html.FileUploadInputElement.name + "." + 'required'.toString());
+const files = Symbol(html.FileUploadInputElement.name + "." + 'files'.toString());
html.FileUploadInputElement[dart.implements] = () => [html.InputElementBase];
dart.setSignature(html.FileUploadInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.FileUploadInputElement, [])}),
@@ -61574,7 +62007,42 @@
static new() {
return html.InputElement.new({type: 'submit'});
}
+ get formAction() {
+ return this[formAction];
+ }
+ set formAction(value) {
+ this[formAction] = value;
+ }
+ get formEnctype() {
+ return this[formEnctype];
+ }
+ set formEnctype(value) {
+ this[formEnctype] = value;
+ }
+ get formMethod() {
+ return this[formMethod];
+ }
+ set formMethod(value) {
+ this[formMethod] = value;
+ }
+ get formNoValidate() {
+ return this[formNoValidate];
+ }
+ set formNoValidate(value) {
+ this[formNoValidate] = value;
+ }
+ get formTarget() {
+ return this[formTarget];
+ }
+ set formTarget(value) {
+ this[formTarget] = value;
+ }
};
+const formAction = Symbol(html.SubmitButtonInputElement.name + "." + 'formAction'.toString());
+const formEnctype = Symbol(html.SubmitButtonInputElement.name + "." + 'formEnctype'.toString());
+const formMethod = Symbol(html.SubmitButtonInputElement.name + "." + 'formMethod'.toString());
+const formNoValidate = Symbol(html.SubmitButtonInputElement.name + "." + 'formNoValidate'.toString());
+const formTarget = Symbol(html.SubmitButtonInputElement.name + "." + 'formTarget'.toString());
html.SubmitButtonInputElement[dart.implements] = () => [html.InputElementBase];
dart.setSignature(html.SubmitButtonInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.SubmitButtonInputElement, [])}),
@@ -61613,7 +62081,70 @@
static new() {
return html.InputElement.new({type: 'image'});
}
+ get alt() {
+ return this[alt];
+ }
+ set alt(value) {
+ this[alt] = value;
+ }
+ get formAction() {
+ return this[formAction];
+ }
+ set formAction(value) {
+ this[formAction] = value;
+ }
+ get formEnctype() {
+ return this[formEnctype];
+ }
+ set formEnctype(value) {
+ this[formEnctype] = value;
+ }
+ get formMethod() {
+ return this[formMethod];
+ }
+ set formMethod(value) {
+ this[formMethod] = value;
+ }
+ get formNoValidate() {
+ return this[formNoValidate];
+ }
+ set formNoValidate(value) {
+ this[formNoValidate] = value;
+ }
+ get formTarget() {
+ return this[formTarget];
+ }
+ set formTarget(value) {
+ this[formTarget] = value;
+ }
+ get height() {
+ return this[height];
+ }
+ set height(value) {
+ this[height] = value;
+ }
+ get src() {
+ return this[src];
+ }
+ set src(value) {
+ this[src] = value;
+ }
+ get width() {
+ return this[width];
+ }
+ set width(value) {
+ this[width] = value;
+ }
};
+const alt = Symbol(html.ImageButtonInputElement.name + "." + 'alt'.toString());
+const formAction = Symbol(html.ImageButtonInputElement.name + "." + 'formAction'.toString());
+const formEnctype = Symbol(html.ImageButtonInputElement.name + "." + 'formEnctype'.toString());
+const formMethod = Symbol(html.ImageButtonInputElement.name + "." + 'formMethod'.toString());
+const formNoValidate = Symbol(html.ImageButtonInputElement.name + "." + 'formNoValidate'.toString());
+const formTarget = Symbol(html.ImageButtonInputElement.name + "." + 'formTarget'.toString());
+const height = Symbol(html.ImageButtonInputElement.name + "." + 'height'.toString());
+const src = Symbol(html.ImageButtonInputElement.name + "." + 'src'.toString());
+const width = Symbol(html.ImageButtonInputElement.name + "." + 'width'.toString());
html.ImageButtonInputElement[dart.implements] = () => [html.InputElementBase];
dart.setSignature(html.ImageButtonInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html.ImageButtonInputElement, [])}),
@@ -64187,8 +64718,8 @@
dart.registerExtension(dart.global.MimeType, html.MimeType);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -64204,11 +64735,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -64237,7 +64768,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -64257,8 +64788,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.MimeType, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.MimeType]),
+ [dartx._get]: dart.definiteFunctionType(html.MimeType, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.MimeType]),
[dartx.elementAt]: dart.definiteFunctionType(html.MimeType, [core.int]),
[dartx.item]: dart.definiteFunctionType(html.MimeType, [core.int]),
[dartx.namedItem]: dart.definiteFunctionType(html.MimeType, [core.String])
@@ -64937,7 +65468,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get hardwareConcurrency() {
+ return this[hardwareConcurrency];
+ }
+ set hardwareConcurrency(value) {
+ super.hardwareConcurrency = value;
+ }
};
+const hardwareConcurrency = Symbol(html.NavigatorCpu.name + "." + 'hardwareConcurrency'.toString());
dart.setSignature(html.NavigatorCpu, {
constructors: () => ({_: dart.definiteFunctionType(html.NavigatorCpu, [])}),
fields: () => ({hardwareConcurrency: core.int})
@@ -64956,7 +65494,56 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get appCodeName() {
+ return this[appCodeName];
+ }
+ set appCodeName(value) {
+ super.appCodeName = value;
+ }
+ get appName() {
+ return this[appName];
+ }
+ set appName(value) {
+ super.appName = value;
+ }
+ get appVersion() {
+ return this[appVersion];
+ }
+ set appVersion(value) {
+ super.appVersion = value;
+ }
+ get dartEnabled() {
+ return this[dartEnabled];
+ }
+ set dartEnabled(value) {
+ super.dartEnabled = value;
+ }
+ get platform() {
+ return this[platform];
+ }
+ set platform(value) {
+ super.platform = value;
+ }
+ get product() {
+ return this[product];
+ }
+ set product(value) {
+ super.product = value;
+ }
+ get userAgent() {
+ return this[userAgent];
+ }
+ set userAgent(value) {
+ super.userAgent = value;
+ }
};
+const appCodeName = Symbol(html.NavigatorID.name + "." + 'appCodeName'.toString());
+const appName = Symbol(html.NavigatorID.name + "." + 'appName'.toString());
+const appVersion = Symbol(html.NavigatorID.name + "." + 'appVersion'.toString());
+const dartEnabled = Symbol(html.NavigatorID.name + "." + 'dartEnabled'.toString());
+const platform = Symbol(html.NavigatorID.name + "." + 'platform'.toString());
+const product = Symbol(html.NavigatorID.name + "." + 'product'.toString());
+const userAgent = Symbol(html.NavigatorID.name + "." + 'userAgent'.toString());
dart.setSignature(html.NavigatorID, {
constructors: () => ({_: dart.definiteFunctionType(html.NavigatorID, [])}),
fields: () => ({
@@ -64986,7 +65573,21 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get language() {
+ return this[language];
+ }
+ set language(value) {
+ super.language = value;
+ }
+ get languages() {
+ return this[languages];
+ }
+ set languages(value) {
+ super.languages = value;
+ }
};
+const language = Symbol(html.NavigatorLanguage.name + "." + 'language'.toString());
+const languages = Symbol(html.NavigatorLanguage.name + "." + 'languages'.toString());
dart.setSignature(html.NavigatorLanguage, {
constructors: () => ({_: dart.definiteFunctionType(html.NavigatorLanguage, [])}),
fields: () => ({
@@ -65002,7 +65603,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get onLine() {
+ return this[onLine];
+ }
+ set onLine(value) {
+ super.onLine = value;
+ }
};
+const onLine = Symbol(html.NavigatorOnLine.name + "." + 'onLine'.toString());
dart.setSignature(html.NavigatorOnLine, {
constructors: () => ({_: dart.definiteFunctionType(html.NavigatorOnLine, [])}),
fields: () => ({onLine: core.bool})
@@ -65119,14 +65727,14 @@
if (index == this.length) {
this[_this][dartx.append](node);
} else {
- this[_this][dartx.insertBefore](node, this.get(index));
+ this[_this][dartx.insertBefore](node, this._get(index));
}
}
insertAll(index, iterable) {
if (index == this.length) {
this.addAll(iterable);
} else {
- let item = this.get(index);
+ let item = this._get(index);
this[_this][dartx.insertAllBefore](iterable, item);
}
}
@@ -65141,7 +65749,7 @@
return result;
}
removeAt(index) {
- let result = this.get(index);
+ let result = this._get(index);
if (result != null) {
this[_this][_removeChild](result);
}
@@ -65173,8 +65781,8 @@
clear() {
this[_this][_clearChildren]();
}
- set(index, value) {
- this[_this][_replaceChild](value, this.get(index));
+ _set(index, value) {
+ this[_this][_replaceChild](value, this._get(index));
return value;
}
get iterator() {
@@ -65202,8 +65810,8 @@
set length(value) {
dart.throw(new core.UnsupportedError("Cannot set length on immutable List."));
}
- get(index) {
- return this[_this][dartx.childNodes][dartx.get](index);
+ _get(index) {
+ return this[_this][dartx.childNodes][dartx._get](index);
}
get rawList() {
return this[_this][dartx.childNodes];
@@ -65234,11 +65842,11 @@
[_filter]: dart.definiteFunctionType(dart.void, [NodeTobool(), core.bool]),
removeWhere: dart.definiteFunctionType(dart.void, [NodeTobool()]),
retainWhere: dart.definiteFunctionType(dart.void, [NodeTobool()]),
- set: dart.definiteFunctionType(dart.void, [core.int, html.Node]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, html.Node]),
sort: dart.definiteFunctionType(dart.void, [], [ComparatorOfNode()]),
setRange: dart.definiteFunctionType(dart.void, [core.int, core.int, IterableOfNode()], [core.int]),
fillRange: dart.definiteFunctionType(dart.void, [core.int, core.int], [html.Node]),
- get: dart.definiteFunctionType(html.Node, [core.int])
+ _get: dart.definiteFunctionType(html.Node, [core.int])
})
});
dart.defineExtensionMembers(html._ChildNodeListLazy, [
@@ -65253,12 +65861,12 @@
'removeWhere',
'retainWhere',
'clear',
- 'set',
+ '_set',
'sort',
'shuffle',
'setRange',
'fillRange',
- 'get',
+ '_get',
'first',
'last',
'single',
@@ -65357,8 +65965,8 @@
dart.registerExtension(dart.global.NodeIterator, html.NodeIterator);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -65372,11 +65980,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -65405,7 +66013,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[_item](index) {
return this.item(index);
@@ -65422,8 +66030,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.Node, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.Node]),
+ [dartx._get]: dart.definiteFunctionType(html.Node, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.Node]),
[dartx.elementAt]: dart.definiteFunctionType(html.Node, [core.int]),
[_item]: dart.definiteFunctionType(html.Node, [core.int])
})
@@ -65494,11 +66102,11 @@
let tag = opts && 'tag' in opts ? opts.tag : null;
let icon = opts && 'icon' in opts ? opts.icon : null;
let parsedOptions = dart.map();
- if (dir != null) parsedOptions[dartx.set]('dir', dir);
- if (body != null) parsedOptions[dartx.set]('body', body);
- if (lang != null) parsedOptions[dartx.set]('lang', lang);
- if (tag != null) parsedOptions[dartx.set]('tag', tag);
- if (icon != null) parsedOptions[dartx.set]('icon', icon);
+ if (dir != null) parsedOptions[dartx._set]('dir', dir);
+ if (body != null) parsedOptions[dartx._set]('body', body);
+ if (lang != null) parsedOptions[dartx._set]('lang', lang);
+ if (tag != null) parsedOptions[dartx._set]('tag', tag);
+ if (icon != null) parsedOptions[dartx._set]('icon', icon);
return html.Notification._factoryNotification(title, parsedOptions);
}
static _() {
@@ -67039,8 +67647,8 @@
dart.registerExtension(dart.global.Plugin, html.Plugin);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -67057,11 +67665,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -67090,7 +67698,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -67113,8 +67721,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.Plugin, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.Plugin]),
+ [dartx._get]: dart.definiteFunctionType(html.Plugin, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.Plugin]),
[dartx.elementAt]: dart.definiteFunctionType(html.Plugin, [core.int]),
[dartx.item]: dart.definiteFunctionType(html.Plugin, [core.int]),
[dartx.namedItem]: dart.definiteFunctionType(html.Plugin, [core.String]),
@@ -69561,7 +70169,7 @@
let options = this[dartx.options][dartx.where](dart.fn(o => o[dartx.selected], OptionElementTobool()))[dartx.toList]();
return new (UnmodifiableListViewOfOptionElement())(options);
} else {
- return JSArrayOfOptionElement().of([this[dartx.options][dartx.get](this[dartx.selectedIndex])]);
+ return JSArrayOfOptionElement().of([this[dartx.options][dartx._get](this[dartx.selectedIndex])]);
}
}
};
@@ -70529,8 +71137,8 @@
dart.registerExtension(dart.global.SourceBuffer, html.SourceBuffer);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -70545,11 +71153,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -70578,7 +71186,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -70595,8 +71203,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.SourceBuffer, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.SourceBuffer]),
+ [dartx._get]: dart.definiteFunctionType(html.SourceBuffer, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.SourceBuffer]),
[dartx.elementAt]: dart.definiteFunctionType(html.SourceBuffer, [core.int]),
[dartx.item]: dart.definiteFunctionType(html.SourceBuffer, [core.int])
})
@@ -70766,8 +71374,8 @@
dart.registerExtension(dart.global.SpeechGrammar, html.SpeechGrammar);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -70790,11 +71398,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -70823,7 +71431,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.addFromString](string, weight) {
return this.addFromString(string, weight);
@@ -70849,8 +71457,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.SpeechGrammar, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.SpeechGrammar]),
+ [dartx._get]: dart.definiteFunctionType(html.SpeechGrammar, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.SpeechGrammar]),
[dartx.elementAt]: dart.definiteFunctionType(html.SpeechGrammar, [core.int]),
[dartx.addFromString]: dart.definiteFunctionType(dart.void, [core.String], [core.num]),
[dartx.addFromUri]: dart.definiteFunctionType(dart.void, [core.String], [core.num]),
@@ -71542,8 +72150,8 @@
'addAll',
'containsValue',
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -71557,7 +72165,7 @@
html.Storage = class Storage extends _interceptors.Interceptor {
[dartx.addAll](other) {
other[dartx.forEach](dart.fn((k, v) => {
- this[dartx.set](k, v);
+ this[dartx._set](k, v);
}, StringAndStringTovoid()));
}
[dartx.containsValue](value) {
@@ -71566,19 +72174,19 @@
[dartx.containsKey](key) {
return this[_getItem](core.String._check(key)) != null;
}
- [dartx.get](key) {
+ [dartx._get](key) {
return this[_getItem](core.String._check(key));
}
- [dartx.set](key, value) {
+ [dartx._set](key, value) {
this[_setItem](key, value);
return value;
}
[dartx.putIfAbsent](key, ifAbsent) {
- if (!dart.test(this[dartx.containsKey](key))) this[dartx.set](key, ifAbsent());
- return this[dartx.get](key);
+ if (!dart.test(this[dartx.containsKey](key))) this[dartx._set](key, ifAbsent());
+ return this[dartx._get](key);
}
[dartx.remove](key) {
- let value = this[dartx.get](key);
+ let value = this[dartx._get](key);
this[_removeItem](core.String._check(key));
return value;
}
@@ -71589,7 +72197,7 @@
for (let i = 0; true; i++) {
let key = this[_key](i);
if (key == null) return;
- f(key, this[dartx.get](key));
+ f(key, this[dartx._get](key));
}
}
get [dartx.keys]() {
@@ -71657,8 +72265,8 @@
[dartx.addAll]: dart.definiteFunctionType(dart.void, [MapOfString$String()]),
[dartx.containsValue]: dart.definiteFunctionType(core.bool, [core.Object]),
[dartx.containsKey]: dart.definiteFunctionType(core.bool, [core.Object]),
- [dartx.get]: dart.definiteFunctionType(core.String, [core.Object]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.Object]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.String, core.String]),
[dartx.putIfAbsent]: dart.definiteFunctionType(core.String, [core.String, VoidToString()]),
[dartx.remove]: dart.definiteFunctionType(core.String, [core.Object]),
[dartx.clear]: dart.definiteFunctionType(dart.void, []),
@@ -72987,8 +73595,8 @@
dart.registerExtension(dart.global.TextTrackCue, html.TextTrackCue);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -73004,11 +73612,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -73037,7 +73645,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.getCueById](id) {
return this.getCueById(id);
@@ -73057,8 +73665,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.TextTrackCue, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.TextTrackCue]),
+ [dartx._get]: dart.definiteFunctionType(html.TextTrackCue, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.TextTrackCue]),
[dartx.elementAt]: dart.definiteFunctionType(html.TextTrackCue, [core.int]),
[dartx.getCueById]: dart.definiteFunctionType(html.TextTrackCue, [core.String]),
[dartx.item]: dart.definiteFunctionType(html.TextTrackCue, [core.int])
@@ -73067,8 +73675,8 @@
dart.registerExtension(dart.global.TextTrackCueList, html.TextTrackCueList);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -73086,11 +73694,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -73119,7 +73727,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.getTrackById](id) {
return this.getTrackById(id);
@@ -73147,8 +73755,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.TextTrack, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.TextTrack]),
+ [dartx._get]: dart.definiteFunctionType(html.TextTrack, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.TextTrack]),
[dartx.elementAt]: dart.definiteFunctionType(html.TextTrack, [core.int]),
[dartx.getTrackById]: dart.definiteFunctionType(html.TextTrack, [core.String]),
[dartx.item]: dart.definiteFunctionType(html.TextTrack, [core.int])
@@ -73433,8 +74041,8 @@
dart.registerExtension(dart.global.TouchEvent, html.TouchEvent);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -73455,11 +74063,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -73488,7 +74096,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -73508,8 +74116,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.Touch, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.Touch]),
+ [dartx._get]: dart.definiteFunctionType(html.Touch, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.Touch]),
[dartx.elementAt]: dart.definiteFunctionType(html.Touch, [core.int]),
[dartx.item]: dart.definiteFunctionType(html.Touch, [core.int])
}),
@@ -74061,7 +74669,84 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get hash() {
+ return this[hash];
+ }
+ set hash(value) {
+ this[hash] = value;
+ }
+ get host() {
+ return this[host];
+ }
+ set host(value) {
+ this[host] = value;
+ }
+ get hostname() {
+ return this[hostname];
+ }
+ set hostname(value) {
+ this[hostname] = value;
+ }
+ get href() {
+ return this[href];
+ }
+ set href(value) {
+ this[href] = value;
+ }
+ get origin() {
+ return this[origin];
+ }
+ set origin(value) {
+ super.origin = value;
+ }
+ get password() {
+ return this[password];
+ }
+ set password(value) {
+ this[password] = value;
+ }
+ get pathname() {
+ return this[pathname];
+ }
+ set pathname(value) {
+ this[pathname] = value;
+ }
+ get port() {
+ return this[port];
+ }
+ set port(value) {
+ this[port] = value;
+ }
+ get protocol() {
+ return this[protocol];
+ }
+ set protocol(value) {
+ this[protocol] = value;
+ }
+ get search() {
+ return this[search];
+ }
+ set search(value) {
+ this[search] = value;
+ }
+ get username() {
+ return this[username];
+ }
+ set username(value) {
+ this[username] = value;
+ }
};
+const hash = Symbol(html.UrlUtils.name + "." + 'hash'.toString());
+const host = Symbol(html.UrlUtils.name + "." + 'host'.toString());
+const hostname = Symbol(html.UrlUtils.name + "." + 'hostname'.toString());
+const href = Symbol(html.UrlUtils.name + "." + 'href'.toString());
+const origin = Symbol(html.UrlUtils.name + "." + 'origin'.toString());
+const password = Symbol(html.UrlUtils.name + "." + 'password'.toString());
+const pathname = Symbol(html.UrlUtils.name + "." + 'pathname'.toString());
+const port = Symbol(html.UrlUtils.name + "." + 'port'.toString());
+const protocol = Symbol(html.UrlUtils.name + "." + 'protocol'.toString());
+const search = Symbol(html.UrlUtils.name + "." + 'search'.toString());
+const username = Symbol(html.UrlUtils.name + "." + 'username'.toString());
dart.setSignature(html.UrlUtils, {
constructors: () => ({_: dart.definiteFunctionType(html.UrlUtils, [])}),
fields: () => ({
@@ -74116,7 +74801,70 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get hash() {
+ return this[hash];
+ }
+ set hash(value) {
+ super.hash = value;
+ }
+ get host() {
+ return this[host];
+ }
+ set host(value) {
+ super.host = value;
+ }
+ get hostname() {
+ return this[hostname];
+ }
+ set hostname(value) {
+ super.hostname = value;
+ }
+ get href() {
+ return this[href];
+ }
+ set href(value) {
+ super.href = value;
+ }
+ get origin() {
+ return this[origin];
+ }
+ set origin(value) {
+ super.origin = value;
+ }
+ get pathname() {
+ return this[pathname];
+ }
+ set pathname(value) {
+ super.pathname = value;
+ }
+ get port() {
+ return this[port];
+ }
+ set port(value) {
+ super.port = value;
+ }
+ get protocol() {
+ return this[protocol];
+ }
+ set protocol(value) {
+ super.protocol = value;
+ }
+ get search() {
+ return this[search];
+ }
+ set search(value) {
+ super.search = value;
+ }
};
+const hash = Symbol(html.UrlUtilsReadOnly.name + "." + 'hash'.toString());
+const host = Symbol(html.UrlUtilsReadOnly.name + "." + 'host'.toString());
+const hostname = Symbol(html.UrlUtilsReadOnly.name + "." + 'hostname'.toString());
+const href = Symbol(html.UrlUtilsReadOnly.name + "." + 'href'.toString());
+const origin = Symbol(html.UrlUtilsReadOnly.name + "." + 'origin'.toString());
+const pathname = Symbol(html.UrlUtilsReadOnly.name + "." + 'pathname'.toString());
+const port = Symbol(html.UrlUtilsReadOnly.name + "." + 'port'.toString());
+const protocol = Symbol(html.UrlUtilsReadOnly.name + "." + 'protocol'.toString());
+const search = Symbol(html.UrlUtilsReadOnly.name + "." + 'search'.toString());
dart.setSignature(html.UrlUtilsReadOnly, {
constructors: () => ({_: dart.definiteFunctionType(html.UrlUtilsReadOnly, [])}),
fields: () => ({
@@ -77183,8 +77931,8 @@
});
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77199,11 +77947,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.item](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77232,7 +77980,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__getter__](index) {
return this.__getter__(index);
@@ -77252,8 +78000,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, RectangleOfnum()]),
+ [dartx._get]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, RectangleOfnum()]),
[dartx.elementAt]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
[__getter__]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
[dartx.item]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int])
@@ -77263,8 +78011,8 @@
dart.registerExtension(dart.global.DOMRectList, html._ClientRectList);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77279,11 +78027,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77312,7 +78060,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -77329,8 +78077,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.CssRule, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.CssRule]),
+ [dartx._get]: dart.definiteFunctionType(html.CssRule, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.CssRule]),
[dartx.elementAt]: dart.definiteFunctionType(html.CssRule, [core.int]),
[dartx.item]: dart.definiteFunctionType(html.CssRule, [core.int])
})
@@ -77516,8 +78264,8 @@
dart.registerExtension(dart.global.FileWriterSync, html._FileWriterSync);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77532,11 +78280,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77565,7 +78313,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -77582,8 +78330,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.Gamepad, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.Gamepad]),
+ [dartx._get]: dart.definiteFunctionType(html.Gamepad, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.Gamepad]),
[dartx.elementAt]: dart.definiteFunctionType(html.Gamepad, [core.int]),
[dartx.item]: dart.definiteFunctionType(html.Gamepad, [core.int])
})
@@ -77701,8 +78449,8 @@
dart.registerExtension(dart.global.HTMLMarqueeElement, html._HTMLMarqueeElement);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77723,11 +78471,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77756,7 +78504,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.getNamedItem](name) {
return this.getNamedItem(name);
@@ -77791,8 +78539,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.Node, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.Node]),
+ [dartx._get]: dart.definiteFunctionType(html.Node, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.Node]),
[dartx.elementAt]: dart.definiteFunctionType(html.Node, [core.int]),
[dartx.getNamedItem]: dart.definiteFunctionType(html._Attr, [core.String]),
[dartx.getNamedItemNS]: dart.definiteFunctionType(html._Attr, [core.String, core.String]),
@@ -77935,8 +78683,8 @@
dart.registerExtension(dart.global.ServiceWorker, html._ServiceWorker);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77951,11 +78699,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77984,7 +78732,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -78001,8 +78749,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.SpeechRecognitionResult, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.SpeechRecognitionResult]),
+ [dartx._get]: dart.definiteFunctionType(html.SpeechRecognitionResult, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.SpeechRecognitionResult]),
[dartx.elementAt]: dart.definiteFunctionType(html.SpeechRecognitionResult, [core.int]),
[dartx.item]: dart.definiteFunctionType(html.SpeechRecognitionResult, [core.int])
})
@@ -78010,8 +78758,8 @@
dart.registerExtension(dart.global.SpeechRecognitionResultList, html._SpeechRecognitionResultList);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -78026,11 +78774,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -78059,7 +78807,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__getter__](name) {
return this.__getter__(name);
@@ -78079,8 +78827,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html.StyleSheet, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html.StyleSheet]),
+ [dartx._get]: dart.definiteFunctionType(html.StyleSheet, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html.StyleSheet]),
[dartx.elementAt]: dart.definiteFunctionType(html.StyleSheet, [core.int]),
[__getter__]: dart.definiteFunctionType(html.CssStyleSheet, [core.String]),
[dartx.item]: dart.definiteFunctionType(html.StyleSheet, [core.int])
@@ -78170,7 +78918,7 @@
}
addAll(other) {
other[dartx.forEach](dart.fn((k, v) => {
- this.set(k, v);
+ this._set(k, v);
}, StringAndStringTovoid()));
}
containsValue(value) {
@@ -78183,9 +78931,9 @@
}
putIfAbsent(key, ifAbsent) {
if (!dart.test(this[dartx.containsKey](key))) {
- this.set(key, ifAbsent());
+ this._set(key, ifAbsent());
}
- return this.get(key);
+ return this._get(key);
}
clear() {
for (let key of this.keys) {
@@ -78194,7 +78942,7 @@
}
forEach(f) {
for (let key of this.keys) {
- let value = this.get(key);
+ let value = this._get(key);
f(key, value);
}
}
@@ -78202,7 +78950,7 @@
let attributes = this[_element][_attributes];
let keys = JSArrayOfString().of([]);
for (let i = 0, len = attributes[dartx.length]; i < dart.notNull(len); i++) {
- let attr = html._Attr._check(attributes[dartx.get](i));
+ let attr = html._Attr._check(attributes[dartx._get](i));
if (dart.test(this[_matches](attr))) {
keys[dartx.add](attr[dartx.name]);
}
@@ -78213,7 +78961,7 @@
let attributes = this[_element][_attributes];
let values = JSArrayOfString().of([]);
for (let i = 0, len = attributes[dartx.length]; i < dart.notNull(len); i++) {
- let attr = html._Attr._check(attributes[dartx.get](i));
+ let attr = html._Attr._check(attributes[dartx._get](i));
if (dart.test(this[_matches](attr))) {
values[dartx.add](attr[dartx.value]);
}
@@ -78263,10 +79011,10 @@
containsKey(key) {
return this[_element][_hasAttribute](core.String._check(key));
}
- get(key) {
+ _get(key) {
return this[_element][dartx.getAttribute](core.String._check(key));
}
- set(key, value) {
+ _set(key, value) {
this[_element][dartx.setAttribute](key, value);
return value;
}
@@ -78287,16 +79035,16 @@
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
- get: dart.definiteFunctionType(core.String, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ _get: dart.definiteFunctionType(core.String, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
remove: dart.definiteFunctionType(core.String, [core.Object]),
[_matches]: dart.definiteFunctionType(core.bool, [html.Node])
})
});
dart.defineExtensionMembers(html._ElementAttributeMap, [
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'remove',
'length'
]);
@@ -78309,15 +79057,15 @@
containsKey(key) {
return this[_element][_hasAttributeNS](this[_namespace], core.String._check(key));
}
- get(key) {
+ _get(key) {
return this[_element][dartx.getAttributeNS](this[_namespace], core.String._check(key));
}
- set(key, value) {
+ _set(key, value) {
this[_element][dartx.setAttributeNS](this[_namespace], key, value);
return value;
}
remove(key) {
- let value = this.get(key);
+ let value = this._get(key);
this[_element][_removeAttributeNS](this[_namespace], core.String._check(key));
return value;
}
@@ -78334,16 +79082,16 @@
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
- get: dart.definiteFunctionType(core.String, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ _get: dart.definiteFunctionType(core.String, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
remove: dart.definiteFunctionType(core.String, [core.Object]),
[_matches]: dart.definiteFunctionType(core.bool, [html.Node])
})
});
dart.defineExtensionMembers(html._NamespacedAttributeMap, [
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'remove',
'length'
]);
@@ -78357,7 +79105,7 @@
}
addAll(other) {
other[dartx.forEach](dart.fn((k, v) => {
- this.set(k, v);
+ this._set(k, v);
}, StringAndStringTovoid()));
}
containsValue(value) {
@@ -78366,11 +79114,11 @@
containsKey(key) {
return this[_attributes][dartx.containsKey](this[_attr](core.String._check(key)));
}
- get(key) {
- return this[_attributes][dartx.get](this[_attr](core.String._check(key)));
+ _get(key) {
+ return this[_attributes][dartx._get](this[_attr](core.String._check(key)));
}
- set(key, value) {
- this[_attributes][dartx.set](this[_attr](key), value);
+ _set(key, value) {
+ this[_attributes][dartx._set](this[_attr](key), value);
return value;
}
putIfAbsent(key, ifAbsent) {
@@ -78432,9 +79180,9 @@
let segments = hyphenedName[dartx.split]('-');
let start = dart.test(startUppercase) ? 0 : 1;
for (let i = start; i < dart.notNull(segments[dartx.length]); i++) {
- let segment = segments[dartx.get](i);
+ let segment = segments[dartx._get](i);
if (dart.notNull(segment[dartx.length]) > 0) {
- segments[dartx.set](i, dart.str`${segment[dartx.get](0)[dartx.toUpperCase]()}${segment[dartx.substring](1)}`);
+ segments[dartx._set](i, dart.str`${segment[dartx._get](0)[dartx.toUpperCase]()}${segment[dartx.substring](1)}`);
}
}
return segments[dartx.join]('');
@@ -78442,8 +79190,8 @@
[_toHyphenedName](word) {
let sb = new core.StringBuffer();
for (let i = 0; i < dart.notNull(word[dartx.length]); i++) {
- let lower = word[dartx.get](i)[dartx.toLowerCase]();
- if (word[dartx.get](i) != lower && i > 0) sb.write('-');
+ let lower = word[dartx._get](i)[dartx.toLowerCase]();
+ if (word[dartx._get](i) != lower && i > 0) sb.write('-');
sb.write(lower);
}
return sb.toString();
@@ -78464,8 +79212,8 @@
addAll: dart.definiteFunctionType(dart.void, [MapOfString$String()]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
- get: dart.definiteFunctionType(core.String, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ _get: dart.definiteFunctionType(core.String, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
putIfAbsent: dart.definiteFunctionType(core.String, [core.String, VoidToString()]),
remove: dart.definiteFunctionType(core.String, [core.Object]),
clear: dart.definiteFunctionType(dart.void, []),
@@ -78481,8 +79229,8 @@
'addAll',
'containsValue',
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -80028,7 +80776,7 @@
add(stream) {
StreamOfT()._check(stream);
if (dart.test(this[_subscriptions][dartx.containsKey](stream))) return;
- this[_subscriptions][dartx.set](stream, stream.listen(dart.bind(this[_controller], 'add'), {onError: dart.bind(this[_controller], 'addError'), onDone: dart.fn(() => this.remove(stream), VoidTovoid())}));
+ this[_subscriptions][dartx._set](stream, stream.listen(dart.bind(this[_controller], 'add'), {onError: dart.bind(this[_controller], 'addError'), onDone: dart.fn(() => this.remove(stream), VoidTovoid())}));
}
remove(stream) {
StreamOfT()._check(stream);
@@ -80112,10 +80860,10 @@
this.uriPolicy = uriPolicy != null ? uriPolicy : html.UriPolicy.new();
if (dart.test(html._Html5NodeValidator._attributeValidators[dartx.isEmpty])) {
for (let attr of html._Html5NodeValidator._standardAttributes) {
- html._Html5NodeValidator._attributeValidators[dartx.set](attr, html._Html5NodeValidator._standardAttributeValidator);
+ html._Html5NodeValidator._attributeValidators[dartx._set](attr, html._Html5NodeValidator._standardAttributeValidator);
}
for (let attr of html._Html5NodeValidator._uriAttributes) {
- html._Html5NodeValidator._attributeValidators[dartx.set](attr, html._Html5NodeValidator._uriAttributeValidator);
+ html._Html5NodeValidator._attributeValidators[dartx._set](attr, html._Html5NodeValidator._uriAttributeValidator);
}
}
}
@@ -80124,9 +80872,9 @@
}
allowsAttribute(element, attributeName, value) {
let tagName = html.Element._safeTagName(element);
- let validator = html._Html5NodeValidator._attributeValidators[dartx.get](dart.str`${tagName}::${attributeName}`);
+ let validator = html._Html5NodeValidator._attributeValidators[dartx._get](dart.str`${tagName}::${attributeName}`);
if (validator == null) {
- validator = html._Html5NodeValidator._attributeValidators[dartx.get](dart.str`*::${attributeName}`);
+ validator = html._Html5NodeValidator._attributeValidators[dartx._get](dart.str`*::${attributeName}`);
}
if (validator == null) {
return false;
@@ -80957,7 +81705,7 @@
if (prevEvent[_shadowCharCode] == event[dartx.charCode]) {
return prevEvent.keyCode;
}
- if ((dart.test(event[dartx.shiftKey]) || dart.test(this[_capsLockOn])) && dart.notNull(event[dartx.charCode]) >= dart.notNull("A"[dartx.codeUnits][dartx.get](0)) && dart.notNull(event[dartx.charCode]) <= dart.notNull("Z"[dartx.codeUnits][dartx.get](0)) && dart.notNull(event[dartx.charCode]) + dart.notNull(html._KeyboardEventHandler._ROMAN_ALPHABET_OFFSET) == prevEvent[_shadowCharCode]) {
+ if ((dart.test(event[dartx.shiftKey]) || dart.test(this[_capsLockOn])) && dart.notNull(event[dartx.charCode]) >= dart.notNull("A"[dartx.codeUnits][dartx._get](0)) && dart.notNull(event[dartx.charCode]) <= dart.notNull("Z"[dartx.codeUnits][dartx._get](0)) && dart.notNull(event[dartx.charCode]) + dart.notNull(html._KeyboardEventHandler._ROMAN_ALPHABET_OFFSET) == prevEvent[_shadowCharCode]) {
return prevEvent.keyCode;
}
}
@@ -81155,7 +81903,7 @@
}
e[_shadowKeyCode] = this[_determineKeyCodeForKeypress](e);
if (e[_shadowKeyIdentifier] != null && dart.test(html._KeyboardEventHandler._keyIdentifier[dartx.containsKey](e[_shadowKeyIdentifier]))) {
- e[_shadowKeyCode] = html._KeyboardEventHandler._keyIdentifier[dartx.get](e[_shadowKeyIdentifier]);
+ e[_shadowKeyCode] = html._KeyboardEventHandler._keyIdentifier[dartx._get](e[_shadowKeyIdentifier]);
}
e[_shadowAltKey] = this[_keyDownList][dartx.any](dart.fn(element => element.altKey, KeyEventTobool()));
this[_stream].add(e);
@@ -81210,7 +81958,7 @@
html._KeyboardEventHandler._keyIdentifier = dart.const(dart.map({Up: html.KeyCode.UP, Down: html.KeyCode.DOWN, Left: html.KeyCode.LEFT, Right: html.KeyCode.RIGHT, Enter: html.KeyCode.ENTER, F1: html.KeyCode.F1, F2: html.KeyCode.F2, F3: html.KeyCode.F3, F4: html.KeyCode.F4, F5: html.KeyCode.F5, F6: html.KeyCode.F6, F7: html.KeyCode.F7, F8: html.KeyCode.F8, F9: html.KeyCode.F9, F10: html.KeyCode.F10, F11: html.KeyCode.F11, F12: html.KeyCode.F12, 'U+007F': html.KeyCode.DELETE, Home: html.KeyCode.HOME, End: html.KeyCode.END, PageUp: html.KeyCode.PAGE_UP, PageDown: html.KeyCode.PAGE_DOWN, Insert: html.KeyCode.INSERT}, core.String, core.int));
dart.defineLazy(html._KeyboardEventHandler, {
get _ROMAN_ALPHABET_OFFSET() {
- return dart.notNull("a"[dartx.codeUnits][dartx.get](0)) - dart.notNull("A"[dartx.codeUnits][dartx.get](0));
+ return dart.notNull("a"[dartx.codeUnits][dartx._get](0)) - dart.notNull("A"[dartx.codeUnits][dartx._get](0));
}
});
html.KeyboardEventStream = class KeyboardEventStream extends core.Object {
@@ -81428,7 +82176,7 @@
}
allowsElement(element) {
if (dart.test(this.allowTypeExtension)) {
- let isAttr = element[dartx.attributes][dartx.get]('is');
+ let isAttr = element[dartx.attributes][dartx._get]('is');
if (isAttr != null) {
return dart.test(this.allowedElements.contains(isAttr[dartx.toUpperCase]())) && dart.test(this.allowedElements.contains(html.Element._safeTagName(element)));
}
@@ -81465,7 +82213,7 @@
if (attributeName == 'template' && value == "") {
return true;
}
- if (element[dartx.attributes][dartx.get]('template') == "") {
+ if (element[dartx.attributes][dartx._get]('template') == "") {
return this[_templateAttrs].contains(attributeName);
}
return false;
@@ -81540,12 +82288,12 @@
clear() {
this[_list][dartx.clear]();
}
- get(index) {
- return html._downcast(html.Node, E)(this[_list][dartx.get](index));
+ _get(index) {
+ return html._downcast(html.Node, E)(this[_list][dartx._get](index));
}
- set(index, value) {
+ _set(index, value) {
E._check(value);
- this[_list][dartx.set](index, value);
+ this[_list][dartx._set](index, value);
return value;
}
set length(newLength) {
@@ -81603,8 +82351,8 @@
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
add: dart.definiteFunctionType(dart.void, [E]),
- get: dart.definiteFunctionType(E, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _get: dart.definiteFunctionType(E, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
sort: dart.definiteFunctionType(dart.void, [], [EAndEToint()]),
insert: dart.definiteFunctionType(dart.void, [core.int, E]),
removeAt: dart.definiteFunctionType(E, [core.int]),
@@ -81617,8 +82365,8 @@
'add',
'remove',
'clear',
- 'get',
- 'set',
+ '_get',
+ '_set',
'sort',
'indexOf',
'lastIndexOf',
@@ -81699,7 +82447,7 @@
moveNext() {
let nextPosition = dart.notNull(this[_position]) + 1;
if (nextPosition < dart.notNull(this[_length])) {
- this[_current] = this[_array][dartx.get](nextPosition);
+ this[_current] = this[_array][dartx._get](nextPosition);
this[_position] = nextPosition;
return true;
}
@@ -81739,7 +82487,7 @@
moveNext() {
let nextPosition = dart.notNull(this[_position]) + 1;
if (nextPosition < dart.notNull(this[_array][dartx.length])) {
- this[_current] = this[_array][dartx.get](nextPosition);
+ this[_current] = this[_array][dartx._get](nextPosition);
this[_position] = nextPosition;
return true;
}
@@ -82324,9 +83072,9 @@
}
let keys = attrs[dartx.keys][dartx.toList]();
for (let i = dart.notNull(attrs[dartx.length]) - 1; i >= 0; --i) {
- let name = keys[dartx.get](i);
- if (!dart.test(this.validator.allowsAttribute(element, core.String._check(dart.dsend(name, 'toLowerCase')), core.String._check(attrs[dartx.get](name))))) {
- html.window[dartx.console].warn('Removing disallowed attribute ' + dart.str`<${tag} ${name}="${attrs[dartx.get](name)}">`);
+ let name = keys[dartx._get](i);
+ if (!dart.test(this.validator.allowsAttribute(element, core.String._check(dart.dsend(name, 'toLowerCase')), core.String._check(attrs[dartx._get](name))))) {
+ html.window[dartx.console].warn('Removing disallowed attribute ' + dart.str`<${tag} ${name}="${attrs[dartx._get](name)}">`);
attrs[dartx.remove](name);
}
}
@@ -82393,17 +83141,17 @@
findSlot(value) {
let length = this.values[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (core.identical(this.values[dartx.get](i), value)) return i;
+ if (core.identical(this.values[dartx._get](i), value)) return i;
}
this.values[dartx.add](value);
this.copies[dartx.add](null);
return length;
}
readSlot(i) {
- return this.copies[dartx.get](i);
+ return this.copies[dartx._get](i);
}
writeSlot(i, x) {
- this.copies[dartx.set](i, x);
+ this.copies[dartx._set](i, x);
}
cleanupSlots() {}
walk(e) {
@@ -82448,7 +83196,7 @@
let copy = this.newJsList(length);
this.writeSlot(slot, copy);
for (; i < dart.notNull(length); i++) {
- dart.dsetindex(copy, i, this.walk(e[dartx.get](i)));
+ dart.dsetindex(copy, i, this.walk(e[dartx._get](i)));
}
return copy;
}
@@ -82482,17 +83230,17 @@
findSlot(value) {
let length = this.values[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (dart.test(this.identicalInJs(this.values[dartx.get](i), value))) return i;
+ if (dart.test(this.identicalInJs(this.values[dartx._get](i), value))) return i;
}
this.values[dartx.add](value);
this.copies[dartx.add](null);
return length;
}
readSlot(i) {
- return this.copies[dartx.get](i);
+ return this.copies[dartx._get](i);
}
writeSlot(i, x) {
- this.copies[dartx.set](i, x);
+ this.copies[dartx._set](i, x);
}
walk(e) {
if (e == null) return e;
@@ -82625,7 +83373,7 @@
let dict = dart.map();
let keys = Object.getOwnPropertyNames(object);
for (let key of core.Iterable._check(keys)) {
- dict[dartx.set](key, object[key]);
+ dict[dartx._set](key, object[key]);
}
return dict;
};
@@ -82861,8 +83609,8 @@
forEach(f) {
this[_filtered][dartx.forEach](f);
}
- set(index, value) {
- this.get(index)[dartx.replaceWith](value);
+ _set(index, value) {
+ this._get(index)[dartx.replaceWith](value);
return value;
}
set length(newLength) {
@@ -82935,7 +83683,7 @@
}
}
removeAt(index) {
- let result = this.get(index);
+ let result = this._get(index);
result[dartx.remove]();
return result;
}
@@ -82951,7 +83699,7 @@
get length() {
return this[_iterable][dartx.length];
}
- get(index) {
+ _get(index) {
return this[_iterable][dartx.elementAt](index);
}
get iterator() {
@@ -82980,7 +83728,7 @@
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
forEach: dart.definiteFunctionType(dart.void, [ElementTovoid()]),
- set: dart.definiteFunctionType(dart.void, [core.int, html.Element]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, html.Element]),
add: dart.definiteFunctionType(dart.void, [html.Element]),
addAll: dart.definiteFunctionType(dart.void, [IterableOfElement()]),
sort: dart.definiteFunctionType(dart.void, [], [ElementAndElementToint()]),
@@ -82991,12 +83739,12 @@
insert: dart.definiteFunctionType(dart.void, [core.int, html.Element]),
insertAll: dart.definiteFunctionType(dart.void, [core.int, IterableOfElement()]),
removeAt: dart.definiteFunctionType(html.Element, [core.int]),
- get: dart.definiteFunctionType(html.Element, [core.int])
+ _get: dart.definiteFunctionType(html.Element, [core.int])
})
});
dart.defineExtensionMembers(html_common.FilteredElementList, [
'forEach',
- 'set',
+ '_set',
'add',
'addAll',
'contains',
@@ -83011,7 +83759,7 @@
'insertAll',
'removeAt',
'remove',
- 'get',
+ '_get',
'length',
'reversed',
'length',
@@ -83026,7 +83774,7 @@
startIndex = 0;
}
for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dart.notNull(i) + 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -83040,7 +83788,7 @@
startIndex = dart.notNull(a[dartx.length]) - 1;
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -83051,7 +83799,7 @@
if (dart.notNull(end) < dart.notNull(start)) dart.throw(new core.RangeError.value(end));
if (dart.notNull(end) > dart.notNull(a[dartx.length])) dart.throw(new core.RangeError.value(end));
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- accumulator[dartx.add](a[dartx.get](i));
+ accumulator[dartx.add](a[dartx._get](i));
}
return accumulator;
}
@@ -86273,7 +87021,42 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get height() {
+ return this[height];
+ }
+ set height(value) {
+ super.height = value;
+ }
+ get result() {
+ return this[result];
+ }
+ set result(value) {
+ super.result = value;
+ }
+ get width() {
+ return this[width];
+ }
+ set width(value) {
+ super.width = value;
+ }
+ get x() {
+ return this[x];
+ }
+ set x(value) {
+ super.x = value;
+ }
+ get y() {
+ return this[y];
+ }
+ set y(value) {
+ super.y = value;
+ }
};
+const height = Symbol(svg.FilterPrimitiveStandardAttributes.name + "." + 'height'.toString());
+const result = Symbol(svg.FilterPrimitiveStandardAttributes.name + "." + 'result'.toString());
+const width = Symbol(svg.FilterPrimitiveStandardAttributes.name + "." + 'width'.toString());
+const x = Symbol(svg.FilterPrimitiveStandardAttributes.name + "." + 'x'.toString());
+const y = Symbol(svg.FilterPrimitiveStandardAttributes.name + "." + 'y'.toString());
dart.setSignature(svg.FilterPrimitiveStandardAttributes, {
constructors: () => ({_: dart.definiteFunctionType(svg.FilterPrimitiveStandardAttributes, [])}),
fields: () => ({
@@ -86299,7 +87082,21 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get preserveAspectRatio() {
+ return this[preserveAspectRatio];
+ }
+ set preserveAspectRatio(value) {
+ super.preserveAspectRatio = value;
+ }
+ get viewBox() {
+ return this[viewBox];
+ }
+ set viewBox(value) {
+ super.viewBox = value;
+ }
};
+const preserveAspectRatio = Symbol(svg.FitToViewBox.name + "." + 'preserveAspectRatio'.toString());
+const viewBox = Symbol(svg.FitToViewBox.name + "." + 'viewBox'.toString());
dart.setSignature(svg.FitToViewBox, {
constructors: () => ({_: dart.definiteFunctionType(svg.FitToViewBox, [])}),
fields: () => ({
@@ -86522,8 +87319,8 @@
const __setter__ = Symbol('__setter__');
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -86548,11 +87345,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -86581,7 +87378,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__](index, newItem) {
return this.__setter__(index, newItem);
@@ -86620,8 +87417,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg.Length, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg.Length]),
+ [dartx._get]: dart.definiteFunctionType(svg.Length, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg.Length]),
[dartx.elementAt]: dart.definiteFunctionType(svg.Length, [core.int]),
[__setter__]: dart.definiteFunctionType(dart.void, [core.int, svg.Length]),
[dartx.appendItem]: dart.definiteFunctionType(svg.Length, [svg.Length]),
@@ -87128,8 +87925,8 @@
dart.registerExtension(dart.global.SVGNumber, svg.Number);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -87154,11 +87951,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -87187,7 +87984,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__](index, newItem) {
return this.__setter__(index, newItem);
@@ -87226,8 +88023,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg.Number, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg.Number]),
+ [dartx._get]: dart.definiteFunctionType(svg.Number, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg.Number]),
[dartx.elementAt]: dart.definiteFunctionType(svg.Number, [core.int]),
[__setter__]: dart.definiteFunctionType(dart.void, [core.int, svg.Number]),
[dartx.appendItem]: dart.definiteFunctionType(svg.Number, [svg.Number]),
@@ -88113,8 +88910,8 @@
dart.registerExtension(dart.global.SVGPathSegLinetoVerticalRel, svg.PathSegLinetoVerticalRel);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -88139,11 +88936,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -88172,7 +88969,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__](index, newItem) {
return this.__setter__(index, newItem);
@@ -88211,8 +89008,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg.PathSeg, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg.PathSeg]),
+ [dartx._get]: dart.definiteFunctionType(svg.PathSeg, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg.PathSeg]),
[dartx.elementAt]: dart.definiteFunctionType(svg.PathSeg, [core.int]),
[__setter__]: dart.definiteFunctionType(dart.void, [core.int, svg.PathSeg]),
[dartx.appendItem]: dart.definiteFunctionType(svg.PathSeg, [svg.PathSeg]),
@@ -88878,8 +89675,8 @@
dart.registerExtension(dart.global.SVGStopElement, svg.StopElement);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -88904,11 +89701,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -88937,7 +89734,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__](index, newItem) {
return this.__setter__(index, newItem);
@@ -88976,8 +89773,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.String, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
[dartx.elementAt]: dart.definiteFunctionType(core.String, [core.int]),
[__setter__]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
[dartx.appendItem]: dart.definiteFunctionType(core.String, [core.String]),
@@ -89052,7 +89849,7 @@
this[_element] = element;
}
readClasses() {
- let classname = this[_element][dartx.attributes][dartx.get]('class');
+ let classname = this[_element][dartx.attributes][dartx._get]('class');
let s = LinkedHashSetOfString().new();
if (classname == null) {
return s;
@@ -89066,7 +89863,7 @@
return s;
}
writeClasses(s) {
- this[_element][dartx.attributes][dartx.set]('class', s.join(' '));
+ this[_element][dartx.attributes][dartx._set]('class', s.join(' '));
}
};
dart.setSignature(svg._AttributeClassSet, {
@@ -89121,7 +89918,7 @@
svg.SvgSvgElement = class SvgSvgElement extends svg.GraphicsElement {
static new() {
let el = svg.SvgElement.tag("svg");
- el[dartx.attributes][dartx.set]('version', "1.1");
+ el[dartx.attributes][dartx._set]('version', "1.1");
return svg.SvgSvgElement._check(el);
}
static _() {
@@ -89546,7 +90343,28 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get requiredExtensions() {
+ return this[requiredExtensions];
+ }
+ set requiredExtensions(value) {
+ super.requiredExtensions = value;
+ }
+ get requiredFeatures() {
+ return this[requiredFeatures];
+ }
+ set requiredFeatures(value) {
+ super.requiredFeatures = value;
+ }
+ get systemLanguage() {
+ return this[systemLanguage];
+ }
+ set systemLanguage(value) {
+ super.systemLanguage = value;
+ }
};
+const requiredExtensions = Symbol(svg.Tests.name + "." + 'requiredExtensions'.toString());
+const requiredFeatures = Symbol(svg.Tests.name + "." + 'requiredFeatures'.toString());
+const systemLanguage = Symbol(svg.Tests.name + "." + 'systemLanguage'.toString());
dart.setSignature(svg.Tests, {
constructors: () => ({_: dart.definiteFunctionType(svg.Tests, [])}),
fields: () => ({
@@ -89733,8 +90551,8 @@
dart.registerExtension(dart.global.SVGTransform, svg.Transform);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -89761,11 +90579,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -89794,7 +90612,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__](index, newItem) {
return this.__setter__(index, newItem);
@@ -89839,8 +90657,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg.Transform, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg.Transform]),
+ [dartx._get]: dart.definiteFunctionType(svg.Transform, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg.Transform]),
[dartx.elementAt]: dart.definiteFunctionType(svg.Transform, [core.int]),
[__setter__]: dart.definiteFunctionType(dart.void, [core.int, svg.Transform]),
[dartx.appendItem]: dart.definiteFunctionType(svg.Transform, [svg.Transform]),
@@ -89878,7 +90696,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get href() {
+ return this[href];
+ }
+ set href(value) {
+ super.href = value;
+ }
};
+const href = Symbol(svg.UriReference.name + "." + 'href'.toString());
dart.setSignature(svg.UriReference, {
constructors: () => ({_: dart.definiteFunctionType(svg.UriReference, [])}),
fields: () => ({href: svg.AnimatedString})
@@ -90060,7 +90885,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get zoomAndPan() {
+ return this[zoomAndPan];
+ }
+ set zoomAndPan(value) {
+ this[zoomAndPan] = value;
+ }
};
+const zoomAndPan = Symbol(svg.ZoomAndPan.name + "." + 'zoomAndPan'.toString());
dart.setSignature(svg.ZoomAndPan, {
constructors: () => ({_: dart.definiteFunctionType(svg.ZoomAndPan, [])}),
fields: () => ({zoomAndPan: core.int}),
@@ -93803,8 +94635,8 @@
const _item_1 = Symbol('_item_1');
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -93819,11 +94651,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.item](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -93852,7 +94684,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return html_common.convertNativeToDart_Dictionary(this[_item_1](index));
@@ -93872,8 +94704,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.Map, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, core.Map]),
+ [dartx._get]: dart.definiteFunctionType(core.Map, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, core.Map]),
[dartx.elementAt]: dart.definiteFunctionType(core.Map, [core.int]),
[dartx.item]: dart.definiteFunctionType(core.Map, [core.int]),
[_item_1]: dart.definiteFunctionType(dart.dynamic, [dart.dynamic])
diff --git a/pkg/dev_compiler/lib/js/legacy/dart_sdk.js b/pkg/dev_compiler/lib/js/legacy/dart_sdk.js
index ca17e4e..d92f36b 100644
--- a/pkg/dev_compiler/lib/js/legacy/dart_sdk.js
+++ b/pkg/dev_compiler/lib/js/legacy/dart_sdk.js
@@ -1037,7 +1037,6 @@
let proto = type.prototype;
for (let name of methodNames) {
let method = dart.getOwnPropertyDescriptor(proto, name);
- if (!method) continue;
dart.defineProperty(proto, dart.getExtensionSymbol(name), method);
}
let originalSigFn = dart.getOwnPropertyDescriptor(type, dart._methodSig).get;
@@ -1604,9 +1603,9 @@
dart.getDynamicStats = function() {
let ret = JSArrayOfListOfObject().of([]);
let keys = dart._callMethodStats[dartx.keys][dartx.toList]();
- keys[dartx.sort](dart.fn((a, b) => dart._callMethodStats[dartx.get](b).count[dartx.compareTo](dart._callMethodStats[dartx.get](a).count), StringAndStringToint()));
+ keys[dartx.sort](dart.fn((a, b) => dart._callMethodStats[dartx._get](b).count[dartx.compareTo](dart._callMethodStats[dartx._get](a).count), StringAndStringToint()));
for (let key of keys) {
- let stats = dart._callMethodStats[dartx.get](key);
+ let stats = dart._callMethodStats[dartx._get](key);
ret[dartx.add](JSArrayOfObject().of([stats.typeName, stats.frame, stats.count]));
}
return ret;
@@ -1621,7 +1620,7 @@
let stack = stackStr[dartx.split]('\n at ');
let src = '';
for (let i = 2; i < dart.notNull(stack[dartx.length]); ++i) {
- let frame = stack[dartx.get](i);
+ let frame = stack[dartx._get](i);
if (!dart.test(frame[dartx.contains]('dart_sdk.js'))) {
src = frame;
break;
@@ -1647,10 +1646,10 @@
return dart._callMethod(obj, method, typeArgs, args, method);
};
dart.dindex = function(obj, index) {
- return dart._callMethod(obj, 'get', null, [index], '[]');
+ return dart._callMethod(obj, '_get', null, [index], '[]');
};
dart.dsetindex = function(obj, index, value) {
- return dart._callMethod(obj, 'set', null, [index, value], '[]=');
+ return dart._callMethod(obj, '_set', null, [index, value], '[]=');
};
dart._ignoreMemo = function(f) {
let memo = new Map();
@@ -1773,11 +1772,11 @@
for (let i = 0, end = values.length - 1; i < end; i += 2) {
let key = values[i];
let value = values[i + 1];
- map.set(key, value);
+ map._set(key, value);
}
} else if (typeof values === 'object') {
for (let key of dart.getOwnPropertyNames(values)) {
- map.set(key, values[key]);
+ map._set(key, values[key]);
}
}
return map;
@@ -3117,7 +3116,7 @@
if (genericTypeConstructor != null) {
this.recordGenericParameters(core.String._check(name), genericTypeConstructor);
} else {
- nonGenericProperties.set(core.String._check(name), value);
+ nonGenericProperties._set(core.String._check(name), value);
}
}, dynamicAnddynamicTodynamic$()));
nonGenericProperties.forEach(dart.fn((name, value) => {
@@ -3130,13 +3129,13 @@
return children.toList();
}
recordGenericParameters(name, genericTypeConstructor) {
- this.genericParameters.set(name, genericTypeConstructor.toString()[dartx.split](' =>')[dartx.first][dartx.replaceAll](core.RegExp.new('[(|)]'), ''));
+ this.genericParameters._set(name, genericTypeConstructor.toString()[dartx.split](' =>')[dartx.first][dartx.replaceAll](core.RegExp.new('[(|)]'), ''));
}
classChild(name, child) {
let typeName = _debugger.getTypeName(core.Type._check(child));
let parameterName = dart.str`${name}\$`;
if (dart.test(this.genericParameters.keys[dartx.contains](parameterName))) {
- typeName = dart.str`${typeName}<${this.genericParameters.get(parameterName)}>`;
+ typeName = dart.str`${typeName}<${this.genericParameters._get(parameterName)}>`;
_debugger.JSNative.setProperty(child, 'genericTypeName', typeName);
}
return new _debugger.NameValuePair({name: typeName, value: child});
@@ -3726,8 +3725,8 @@
'hashCode',
'length',
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'asMap'
]);
class JSArray extends core.Object {
@@ -3804,7 +3803,7 @@
this[dartx.checkMutable]('setAll');
core.RangeError.checkValueInInterval(index, 0, this[dartx.length], "index");
for (let element of iterable) {
- this[dartx.set]((() => {
+ this[dartx._set]((() => {
let x = index;
index = dart.notNull(x) + 1;
return x;
@@ -3819,7 +3818,7 @@
[dartx.remove](element) {
this[dartx.checkGrowable]('remove');
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
this.splice(i, 1);
return true;
}
@@ -3847,7 +3846,7 @@
if (retained[dartx.length] == end) return;
this[dartx.length] = retained[dartx.length];
for (let i = 0; i < dart.notNull(retained[dartx.length]); i++) {
- this[dartx.set](i, E._check(retained[dartx.get](i)));
+ this[dartx._set](i, E._check(retained[dartx._get](i)));
}
}
[dartx.where](f) {
@@ -3888,7 +3887,7 @@
if (separator === void 0) separator = "";
let list = core.List.new(this[dartx.length]);
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- list[dartx.set](i, dart.str`${this[dartx.get](i)}`);
+ list[dartx._set](i, dart.str`${this[dartx._get](i)}`);
}
return list.join(separator);
}
@@ -3908,7 +3907,7 @@
EAndEToE()._check(combine);
let length = this[dartx.length];
if (length == 0) dart.throw(_internal.IterableElementError.noElement());
- let value = this[dartx.get](0);
+ let value = this[dartx._get](0);
for (let i = 1; i < dart.notNull(length); i++) {
let element = this[i];
value = combine(value, element);
@@ -3975,7 +3974,7 @@
dart.throw(_internal.IterableElementError.noElement());
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.sublist](start, end) {
if (end === void 0) end = null;
@@ -4000,15 +3999,15 @@
return new (SubListIterableOfE())(this, start, end);
}
get [dartx.first]() {
- if (dart.notNull(this[dartx.length]) > 0) return this[dartx.get](0);
+ if (dart.notNull(this[dartx.length]) > 0) return this[dartx._get](0);
dart.throw(_internal.IterableElementError.noElement());
}
get [dartx.last]() {
- if (dart.notNull(this[dartx.length]) > 0) return this[dartx.get](dart.notNull(this[dartx.length]) - 1);
+ if (dart.notNull(this[dartx.length]) > 0) return this[dartx._get](dart.notNull(this[dartx.length]) - 1);
dart.throw(_internal.IterableElementError.noElement());
}
get [dartx.single]() {
- if (this[dartx.length] == 1) return this[dartx.get](0);
+ if (this[dartx.length] == 1) return this[dartx._get](0);
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
dart.throw(_internal.IterableElementError.tooMany());
}
@@ -4040,12 +4039,12 @@
}
if (dart.notNull(otherStart) < dart.notNull(start)) {
for (let i = length - 1; i >= 0; i--) {
- let element = otherList[dartx.get](dart.notNull(otherStart) + i);
+ let element = otherList[dartx._get](dart.notNull(otherStart) + i);
this[dart.notNull(start) + i] = element;
}
} else {
for (let i = 0; i < length; i++) {
- let element = otherList[dartx.get](dart.notNull(otherStart) + i);
+ let element = otherList[dartx._get](dart.notNull(otherStart) + i);
this[dart.notNull(start) + i] = element;
}
}
@@ -4124,9 +4123,9 @@
while (dart.notNull(length) > 1) {
let pos = random.nextInt(length);
length = dart.notNull(length) - 1;
- let tmp = this[dartx.get](length);
- this[dartx.set](length, this[dartx.get](pos));
- this[dartx.set](pos, tmp);
+ let tmp = this[dartx._get](length);
+ this[dartx._set](length, this[dartx._get](pos));
+ this[dartx._set](pos, tmp);
}
}
[dartx.indexOf](element, start) {
@@ -4138,7 +4137,7 @@
start = 0;
}
for (let i = start; dart.notNull(i) < dart.notNull(this[dartx.length]); i = dart.notNull(i) + 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -4157,7 +4156,7 @@
}
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -4165,7 +4164,7 @@
}
[dartx.contains](other) {
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), other)) return true;
+ if (dart.equals(this[dartx._get](i), other)) return true;
}
return false;
}
@@ -4206,12 +4205,12 @@
}
this.length = newLength;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (!(typeof index == 'number')) dart.throw(_js_helper.diagnoseIndexError(this, index));
if (dart.notNull(index) >= dart.notNull(this[dartx.length]) || dart.notNull(index) < 0) dart.throw(_js_helper.diagnoseIndexError(this, index));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
E._check(value);
this[dartx.checkMutable]('indexed set');
if (!(typeof index == 'number')) dart.throw(_js_helper.diagnoseIndexError(this, index));
@@ -4290,8 +4289,8 @@
[dartx.contains]: dart.definiteFunctionType(core.bool, [core.Object]),
[dartx.toList]: dart.definiteFunctionType(core.List$(E), [], {growable: core.bool}),
[dartx.toSet]: dart.definiteFunctionType(core.Set$(E), []),
- [dartx.get]: dart.definiteFunctionType(E, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, E]),
+ [dartx._get]: dart.definiteFunctionType(E, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, E]),
[dartx.asMap]: dart.definiteFunctionType(core.Map$(core.int, E), [])
}),
statics: () => ({
@@ -4366,7 +4365,7 @@
this[_current] = null;
return false;
}
- this[_current] = this[_iterable][dartx.get](this[_index]);
+ this[_current] = this[_iterable][dartx._get](this[_index]);
this[_index] = dart.notNull(this[_index]) + 1;
return true;
}
@@ -4418,7 +4417,7 @@
'toRadixString',
'toString',
'hashCode',
- 'unary-',
+ '_negate',
'+',
'-',
'/',
@@ -4615,7 +4614,7 @@
get [dartx.hashCode]() {
return this & 0x1FFFFFFF;
}
- [dartx['unary-']]() {
+ [dartx._negate]() {
return -this;
}
[dartx['+']](other) {
@@ -4913,7 +4912,7 @@
[dartx.toStringAsExponential]: dart.definiteFunctionType(core.String, [], [core.int]),
[dartx.toStringAsPrecision]: dart.definiteFunctionType(core.String, [core.int]),
[dartx.toRadixString]: dart.definiteFunctionType(core.String, [core.int]),
- [dartx['unary-']]: dart.definiteFunctionType(_interceptors.JSNumber, []),
+ [dartx._negate]: dart.definiteFunctionType(_interceptors.JSNumber, []),
[dartx['+']]: dart.definiteFunctionType(_interceptors.JSNumber, [core.num]),
[dartx['-']]: dart.definiteFunctionType(_interceptors.JSNumber, [core.num]),
[dartx['/']]: dart.definiteFunctionType(core.double, [core.num]),
@@ -4996,7 +4995,7 @@
'hashCode',
'runtimeType',
'length',
- 'get'
+ '_get'
]);
_interceptors.JSString = class JSString extends _interceptors.Interceptor {
new() {
@@ -5379,7 +5378,7 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (!(typeof index == 'number')) dart.throw(_js_helper.diagnoseIndexError(this, index));
if (dart.notNull(index) >= dart.notNull(this[dartx.length]) || dart.notNull(index) < 0) dart.throw(_js_helper.diagnoseIndexError(this, index));
return this[index];
@@ -5423,7 +5422,7 @@
[dartx.lastIndexOf]: dart.definiteFunctionType(core.int, [core.Pattern], [core.int]),
[dartx.contains]: dart.definiteFunctionType(core.bool, [core.Pattern], [core.int]),
[dartx.compareTo]: dart.definiteFunctionType(core.int, [core.String]),
- [dartx.get]: dart.definiteFunctionType(core.String, [core.int])
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.int])
}),
statics: () => ({
_isWhitespace: dart.definiteFunctionType(core.bool, [core.int]),
@@ -5575,12 +5574,12 @@
return new dart.JsIterator(this[dartx.iterator]);
}
elementAt(index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
forEach(action) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- action(this[dartx.get](i));
+ action(this[dartx._get](i));
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5594,21 +5593,21 @@
}
get first() {
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
- return this[dartx.get](0);
+ return this[dartx._get](0);
}
get last() {
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
- return this[dartx.get](dart.notNull(this[dartx.length]) - 1);
+ return this[dartx._get](dart.notNull(this[dartx.length]) - 1);
}
get single() {
if (this[dartx.length] == 0) dart.throw(_internal.IterableElementError.noElement());
if (dart.notNull(this[dartx.length]) > 1) dart.throw(_internal.IterableElementError.tooMany());
- return this[dartx.get](0);
+ return this[dartx._get](0);
}
contains(element) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), element)) return true;
+ if (dart.equals(this[dartx._get](i), element)) return true;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5618,7 +5617,7 @@
every(test) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (!dart.test(test(this[dartx.get](i)))) return false;
+ if (!dart.test(test(this[dartx._get](i)))) return false;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5628,7 +5627,7 @@
any(test) {
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (dart.test(test(this[dartx.get](i)))) return true;
+ if (dart.test(test(this[dartx._get](i)))) return true;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5640,7 +5639,7 @@
VoidToE()._check(orElse);
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- let element = this[dartx.get](i);
+ let element = this[dartx._get](i);
if (dart.test(test(element))) return element;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
@@ -5654,7 +5653,7 @@
VoidToE()._check(orElse);
let length = this[dartx.length];
for (let i = dart.notNull(length) - 1; i >= 0; i--) {
- let element = this[dartx.get](i);
+ let element = this[dartx._get](i);
if (dart.test(test(element))) return element;
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
@@ -5668,7 +5667,7 @@
let match = null;
let matchFound = false;
for (let i = 0; i < dart.notNull(length); i++) {
- let element = this[dartx.get](i);
+ let element = this[dartx._get](i);
if (dart.test(test(element))) {
if (matchFound) {
dart.throw(_internal.IterableElementError.tooMany());
@@ -5707,9 +5706,9 @@
EAndEToE()._check(combine);
let length = this[dartx.length];
if (length == 0) dart.throw(_internal.IterableElementError.noElement());
- let value = this[dartx.get](0);
+ let value = this[dartx._get](0);
for (let i = 1; i < dart.notNull(length); i++) {
- value = combine(value, this[dartx.get](i));
+ value = combine(value, this[dartx._get](i));
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5721,7 +5720,7 @@
let value = initialValue;
let length = this[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- value = combine(value, this[dartx.get](i));
+ value = combine(value, this[dartx._get](i));
if (length != this[dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -5751,20 +5750,20 @@
result = ListOfE().new(this[dartx.length]);
}
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- result[dartx.set](i, this[dartx.get](i));
+ result[dartx._set](i, this[dartx._get](i));
}
return result;
}
toSet() {
let result = SetOfE().new();
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- result.add(this[dartx.get](i));
+ result.add(this[dartx._get](i));
}
return result;
}
add(element) {
E._check(element);
- this[dartx.set]((() => {
+ this[dartx._set]((() => {
let x = this[dartx.length];
this[dartx.length] = dart.notNull(x) + 1;
return x;
@@ -5776,13 +5775,13 @@
for (let element of iterable) {
dart.assert(this[dartx.length] == i || dart.test(dart.throw(new core.ConcurrentModificationError(this))));
this[dartx.length] = dart.notNull(i) + 1;
- this[dartx.set](i, element);
+ this[dartx._set](i, element);
i = dart.notNull(i) + 1;
}
}
remove(element) {
for (let i = 0; i < dart.notNull(this[dartx.length]); i++) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
this[dartx.setRange](i, dart.notNull(this[dartx.length]) - 1, this, i + 1);
this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
return true;
@@ -5800,7 +5799,7 @@
let retained = [];
let length = source[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- let element = source[dartx.get](i);
+ let element = source[dartx._get](i);
if (dart.dcall(test, element) == retainMatching) {
retained[dartx.add](element);
}
@@ -5820,7 +5819,7 @@
if (this[dartx.length] == 0) {
dart.throw(_internal.IterableElementError.noElement());
}
- let result = this[dartx.get](dart.notNull(this[dartx.length]) - 1);
+ let result = this[dartx._get](dart.notNull(this[dartx.length]) - 1);
this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
return result;
}
@@ -5839,9 +5838,9 @@
while (dart.notNull(length) > 1) {
let pos = random.nextInt(length);
length = dart.notNull(length) - 1;
- let tmp = this[dartx.get](length);
- this[dartx.set](length, this[dartx.get](pos));
- this[dartx.set](pos, tmp);
+ let tmp = this[dartx._get](length);
+ this[dartx._set](length, this[dartx._get](pos));
+ this[dartx._set](pos, tmp);
}
}
asMap() {
@@ -5856,7 +5855,7 @@
let result = ListOfE().new();
result[dartx.length] = length;
for (let i = 0; i < length; i++) {
- result[dartx.set](i, this[dartx.get](dart.notNull(start) + i));
+ result[dartx._set](i, this[dartx._get](dart.notNull(start) + i));
}
return result;
}
@@ -5875,7 +5874,7 @@
E._check(fill);
core.RangeError.checkValidRange(start, end, this[dartx.length]);
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- this[dartx.set](i, fill);
+ this[dartx._set](i, fill);
}
}
setRange(start, end, iterable, skipCount) {
@@ -5899,11 +5898,11 @@
}
if (dart.notNull(otherStart) < dart.notNull(start)) {
for (let i = length - 1; i >= 0; i--) {
- this[dartx.set](dart.notNull(start) + i, otherList[dartx.get](dart.notNull(otherStart) + i));
+ this[dartx._set](dart.notNull(start) + i, otherList[dartx._get](dart.notNull(otherStart) + i));
}
} else {
for (let i = 0; i < length; i++) {
- this[dartx.set](dart.notNull(start) + i, otherList[dartx.get](dart.notNull(otherStart) + i));
+ this[dartx._set](dart.notNull(start) + i, otherList[dartx._get](dart.notNull(otherStart) + i));
}
}
}
@@ -5942,7 +5941,7 @@
startIndex = 0;
}
for (let i = startIndex; dart.notNull(i) < dart.notNull(this[dartx.length]); i = dart.notNull(i) + 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -5961,7 +5960,7 @@
}
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(this[dartx.get](i), element)) {
+ if (dart.equals(this[dartx._get](i), element)) {
return i;
}
}
@@ -5977,10 +5976,10 @@
if (!(typeof index == 'number')) dart.throw(new core.ArgumentError(index));
this[dartx.length] = dart.notNull(this[dartx.length]) + 1;
this[dartx.setRange](dart.notNull(index) + 1, this[dartx.length], this, index);
- this[dartx.set](index, element);
+ this[dartx._set](index, element);
}
removeAt(index) {
- let result = this[dartx.get](index);
+ let result = this[dartx._get](index);
this[dartx.setRange](index, dart.notNull(this[dartx.length]) - 1, this, dart.notNull(index) + 1);
this[dartx.length] = dart.notNull(this[dartx.length]) - 1;
return result;
@@ -6006,7 +6005,7 @@
this[dartx.setRange](index, dart.notNull(index) + dart.notNull(iterable[dartx.length]), iterable);
} else {
for (let element of iterable) {
- this[dartx.set]((() => {
+ this[dartx._set]((() => {
let x = index;
index = dart.notNull(x) + 1;
return x;
@@ -6155,7 +6154,7 @@
let ETobool = () => (ETobool = dart.constFn(dart.functionType(core.bool, [E])))();
let ComparatorOfE = () => (ComparatorOfE = dart.constFn(core.Comparator$(E)))();
class UnmodifiableListMixin extends core.Object {
- set(index, value) {
+ _set(index, value) {
E._check(value);
dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable list"));
return value;
@@ -6232,7 +6231,7 @@
dart.setSignature(UnmodifiableListMixin, {
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
setAll: dart.definiteFunctionType(dart.void, [core.int, IterableOfE()]),
add: dart.definiteFunctionType(dart.void, [E]),
insert: dart.definiteFunctionType(dart.void, [core.int, E]),
@@ -6253,7 +6252,7 @@
})
});
dart.defineExtensionMembers(UnmodifiableListMixin, [
- 'set',
+ '_set',
'setAll',
'add',
'insert',
@@ -6322,7 +6321,7 @@
set length(value) {
super.length = value;
}
- get(i) {
+ _get(i) {
return this[_string][dartx.codeUnitAt](i);
}
static stringOf(u) {
@@ -6334,11 +6333,11 @@
constructors: () => ({new: dart.definiteFunctionType(_internal.CodeUnits, [core.String])}),
fields: () => ({[_string]: core.String}),
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
- methods: () => ({get: dart.definiteFunctionType(core.int, [core.int])}),
+ methods: () => ({_get: dart.definiteFunctionType(core.int, [core.int])}),
statics: () => ({stringOf: dart.definiteFunctionType(core.String, [_internal.CodeUnits])}),
names: ['stringOf']
});
- dart.defineExtensionMembers(_internal.CodeUnits, ['get', 'length']);
+ dart.defineExtensionMembers(_internal.CodeUnits, ['_get', 'length']);
_internal.EfficientLength = class EfficientLength extends core.Object {};
core.Iterable$ = dart.generic(E => {
let EmptyIterableOfE = () => (EmptyIterableOfE = dart.constFn(_internal.EmptyIterable$(E)))();
@@ -6857,7 +6856,7 @@
result = ListOfE().new(this.length);
}
for (let i = 0; i < dart.notNull(this.length); i++) {
- result[dartx.set](i, this.elementAt(i));
+ result[dartx._set](i, this.elementAt(i));
}
return result;
}
@@ -7005,7 +7004,7 @@
return _;
})() : ListOfE().new(length);
for (let i = 0; i < length; i++) {
- result[dartx.set](i, this[_iterable$][dartx.elementAt](dart.notNull(start) + i));
+ result[dartx._set](i, this[_iterable$][dartx.elementAt](dart.notNull(start) + i));
if (dart.notNull(this[_iterable$][dartx.length]) < dart.notNull(end)) dart.throw(new core.ConcurrentModificationError(this));
}
return result;
@@ -8055,8 +8054,8 @@
new(values) {
this[_values] = values;
}
- get(key) {
- return dart.test(this.containsKey(key)) ? this[_values][dartx.get](core.int._check(key)) : null;
+ _get(key) {
+ return dart.test(this.containsKey(key)) ? this[_values][dartx._get](core.int._check(key)) : null;
}
get length() {
return this[_values][dartx.length];
@@ -8082,13 +8081,13 @@
forEach(f) {
let length = this[_values][dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- f(i, this[_values][dartx.get](i));
+ f(i, this[_values][dartx._get](i));
if (length != this[_values][dartx.length]) {
dart.throw(new core.ConcurrentModificationError(this[_values]));
}
}
}
- set(key, value) {
+ _set(key, value) {
E._check(value);
dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable map"));
return value;
@@ -8124,11 +8123,11 @@
isNotEmpty: dart.definiteFunctionType(core.bool, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(E, [core.Object]),
+ _get: dart.definiteFunctionType(E, [core.Object]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
forEach: dart.definiteFunctionType(dart.void, [intAndETovoid()]),
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
putIfAbsent: dart.definiteFunctionType(E, [core.int, VoidToE()]),
remove: dart.definiteFunctionType(E, [core.Object]),
clear: dart.definiteFunctionType(dart.void, []),
@@ -8136,11 +8135,11 @@
})
});
dart.defineExtensionMembers(ListMapView, [
- 'get',
+ '_get',
'containsValue',
'containsKey',
'forEach',
- 'set',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -8237,11 +8236,11 @@
static copy(src, srcStart, dst, dstStart, count) {
if (dart.notNull(srcStart) < dart.notNull(dstStart)) {
for (let i = dart.notNull(srcStart) + dart.notNull(count) - 1, j = dart.notNull(dstStart) + dart.notNull(count) - 1; i >= dart.notNull(srcStart); i--, j--) {
- dst[dartx.set](j, src[dartx.get](i));
+ dst[dartx._set](j, src[dartx._get](i));
}
} else {
for (let i = srcStart, j = dstStart; dart.notNull(i) < dart.notNull(srcStart) + dart.notNull(count); i = dart.notNull(i) + 1, j = dart.notNull(j) + 1) {
- dst[dartx.set](j, src[dartx.get](i));
+ dst[dartx._set](j, src[dartx._get](i));
}
}
}
@@ -8251,7 +8250,7 @@
let length = a[dartx.length];
if (!dart.equals(length, dart.dload(b, 'length'))) return false;
for (let i = 0; i < dart.notNull(length); i++) {
- if (!core.identical(a[dartx.get](i), dart.dindex(b, i))) return false;
+ if (!core.identical(a[dartx._get](i), dart.dindex(b, i))) return false;
}
return true;
}
@@ -8263,7 +8262,7 @@
startIndex = 0;
}
for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dart.notNull(i) + 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -8277,7 +8276,7 @@
startIndex = dart.notNull(a[dartx.length]) - 1;
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -8337,13 +8336,13 @@
static _insertionSort(E) {
return (a, left, right, compare) => {
for (let i = dart.notNull(left) + 1; i <= dart.notNull(right); i++) {
- let el = a[dartx.get](i);
+ let el = a[dartx._get](i);
let j = i;
- while (j > dart.notNull(left) && dart.notNull(compare(a[dartx.get](j - 1), el)) > 0) {
- a[dartx.set](j, a[dartx.get](j - 1));
+ while (j > dart.notNull(left) && dart.notNull(compare(a[dartx._get](j - 1), el)) > 0) {
+ a[dartx._set](j, a[dartx._get](j - 1));
j--;
}
- a[dartx.set](j, el);
+ a[dartx._set](j, el);
}
};
}
@@ -8356,11 +8355,11 @@
let index3 = ((dart.notNull(left) + dart.notNull(right)) / 2)[dartx.truncate]();
let index2 = index3 - sixth;
let index4 = index3 + sixth;
- let el1 = a[dartx.get](index1);
- let el2 = a[dartx.get](index2);
- let el3 = a[dartx.get](index3);
- let el4 = a[dartx.get](index4);
- let el5 = a[dartx.get](index5);
+ let el1 = a[dartx._get](index1);
+ let el2 = a[dartx._get](index2);
+ let el3 = a[dartx._get](index3);
+ let el4 = a[dartx._get](index4);
+ let el5 = a[dartx._get](index5);
if (dart.notNull(compare(el1, el2)) > 0) {
let t = el1;
el1 = el2;
@@ -8408,40 +8407,40 @@
}
let pivot1 = el2;
let pivot2 = el4;
- a[dartx.set](index1, el1);
- a[dartx.set](index3, el3);
- a[dartx.set](index5, el5);
- a[dartx.set](index2, a[dartx.get](left));
- a[dartx.set](index4, a[dartx.get](right));
+ a[dartx._set](index1, el1);
+ a[dartx._set](index3, el3);
+ a[dartx._set](index5, el5);
+ a[dartx._set](index2, a[dartx._get](left));
+ a[dartx._set](index4, a[dartx._get](right));
let less = dart.notNull(left) + 1;
let great = dart.notNull(right) - 1;
let pivots_are_equal = compare(pivot1, pivot2) == 0;
if (pivots_are_equal) {
let pivot = pivot1;
for (let k = less; k <= great; k++) {
- let ak = a[dartx.get](k);
+ let ak = a[dartx._get](k);
let comp = compare(ak, pivot);
if (comp == 0) continue;
if (dart.notNull(comp) < 0) {
if (k != less) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less, ak);
}
less++;
} else {
while (true) {
- comp = compare(a[dartx.get](great), pivot);
+ comp = compare(a[dartx._get](great), pivot);
if (dart.notNull(comp) > 0) {
great--;
continue;
} else if (dart.notNull(comp) < 0) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less++, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less++, a[dartx._get](great));
+ a[dartx._set](great--, ak);
break;
} else {
- a[dartx.set](k, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](great));
+ a[dartx._set](great--, ak);
break;
}
}
@@ -8449,32 +8448,32 @@
}
} else {
for (let k = less; k <= great; k++) {
- let ak = a[dartx.get](k);
+ let ak = a[dartx._get](k);
let comp_pivot1 = compare(ak, pivot1);
if (dart.notNull(comp_pivot1) < 0) {
if (k != less) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less, ak);
}
less++;
} else {
let comp_pivot2 = compare(ak, pivot2);
if (dart.notNull(comp_pivot2) > 0) {
while (true) {
- let comp = compare(a[dartx.get](great), pivot2);
+ let comp = compare(a[dartx._get](great), pivot2);
if (dart.notNull(comp) > 0) {
great--;
if (great < k) break;
continue;
} else {
- comp = compare(a[dartx.get](great), pivot1);
+ comp = compare(a[dartx._get](great), pivot1);
if (dart.notNull(comp) < 0) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less++, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less++, a[dartx._get](great));
+ a[dartx._set](great--, ak);
} else {
- a[dartx.set](k, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](great));
+ a[dartx._set](great--, ak);
}
break;
}
@@ -8483,49 +8482,49 @@
}
}
}
- a[dartx.set](left, a[dartx.get](less - 1));
- a[dartx.set](less - 1, pivot1);
- a[dartx.set](right, a[dartx.get](great + 1));
- a[dartx.set](great + 1, pivot2);
+ a[dartx._set](left, a[dartx._get](less - 1));
+ a[dartx._set](less - 1, pivot1);
+ a[dartx._set](right, a[dartx._get](great + 1));
+ a[dartx._set](great + 1, pivot2);
_internal.Sort._doSort(E)(a, left, less - 2, compare);
_internal.Sort._doSort(E)(a, great + 2, right, compare);
if (pivots_are_equal) {
return;
}
if (less < index1 && great > index5) {
- while (compare(a[dartx.get](less), pivot1) == 0) {
+ while (compare(a[dartx._get](less), pivot1) == 0) {
less++;
}
- while (compare(a[dartx.get](great), pivot2) == 0) {
+ while (compare(a[dartx._get](great), pivot2) == 0) {
great--;
}
for (let k = less; k <= great; k++) {
- let ak = a[dartx.get](k);
+ let ak = a[dartx._get](k);
let comp_pivot1 = compare(ak, pivot1);
if (comp_pivot1 == 0) {
if (k != less) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less, ak);
}
less++;
} else {
let comp_pivot2 = compare(ak, pivot2);
if (comp_pivot2 == 0) {
while (true) {
- let comp = compare(a[dartx.get](great), pivot2);
+ let comp = compare(a[dartx._get](great), pivot2);
if (comp == 0) {
great--;
if (great < k) break;
continue;
} else {
- comp = compare(a[dartx.get](great), pivot1);
+ comp = compare(a[dartx._get](great), pivot1);
if (dart.notNull(comp) < 0) {
- a[dartx.set](k, a[dartx.get](less));
- a[dartx.set](less++, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](less));
+ a[dartx._set](less++, a[dartx._get](great));
+ a[dartx._set](great--, ak);
} else {
- a[dartx.set](k, a[dartx.get](great));
- a[dartx.set](great--, ak);
+ a[dartx._set](k, a[dartx._get](great));
+ a[dartx._set](great--, ak);
}
break;
}
@@ -8900,8 +8899,8 @@
return;
}
let message = core.List.new(2);
- message[dartx.set](0, dart.toString(error));
- message[dartx.set](1, stackTrace == null ? null : dart.toString(stackTrace));
+ message[dartx._set](0, dart.toString(error));
+ message[dartx._set](1, stackTrace == null ? null : dart.toString(stackTrace));
for (let port of this.errorPorts)
port.send(message);
}
@@ -8989,13 +8988,13 @@
}
}
lookup(portId) {
- return this.ports[dartx.get](portId);
+ return this.ports[dartx._get](portId);
}
[_addRegistration](portId, port) {
if (dart.test(this.ports[dartx.containsKey](portId))) {
dart.throw(core.Exception.new("Registry: ports must be registered only once."));
}
- this.ports[dartx.set](portId, port);
+ this.ports[dartx._set](portId, port);
}
register(portId, port) {
this[_addRegistration](portId, port);
@@ -9007,7 +9006,7 @@
}
[_updateGlobalState]() {
if (dart.notNull(this.ports[dartx.length]) - dart.notNull(this.weakPorts.length) > 0 || dart.test(this.isPaused) || !dart.test(this.initialized)) {
- _isolate_helper._globalState.isolates[dartx.set](this.id, this);
+ _isolate_helper._globalState.isolates[dartx._set](this.id, this);
} else {
this.kill();
}
@@ -9292,7 +9291,7 @@
}
case 'close':
{
- _isolate_helper._globalState.managers[dartx.remove](_isolate_helper.IsolateNatives.workerIds.get(sender));
+ _isolate_helper._globalState.managers[dartx.remove](_isolate_helper.IsolateNatives.workerIds._get(sender));
sender.terminate();
_isolate_helper._globalState.topEventLoop.run();
break;
@@ -9455,8 +9454,8 @@
let o = _isolate_helper._globalState;
let workerId = o.nextManagerId;
o.nextManagerId = dart.notNull(workerId) + 1;
- _isolate_helper.IsolateNatives.workerIds.set(worker, workerId);
- _isolate_helper._globalState.managers[dartx.set](workerId, worker);
+ _isolate_helper.IsolateNatives.workerIds._set(worker, workerId);
+ _isolate_helper._globalState.managers[dartx._set](workerId, worker);
worker.postMessage(_isolate_helper._serializeMessage(dart.map({command: 'start', id: workerId, replyTo: _isolate_helper._serializeMessage(replyPort), args: args, msg: _isolate_helper._serializeMessage(message), isSpawnUri: isSpawnUri, startPaused: startPaused, functionName: functionName}, core.String, core.Object)));
}
static workerOnError(event, uri, onError) {
@@ -9539,7 +9538,7 @@
super.new(isolateId);
}
send(message) {
- let isolate = _isolate_helper._globalState.isolates[dartx.get](this[_isolateId]);
+ let isolate = _isolate_helper._globalState.isolates[dartx._get](this[_isolateId]);
if (isolate == null) return;
if (dart.test(this[_receivePort][_isClosed])) return;
let msg = _isolate_helper._clone(message);
@@ -9579,7 +9578,7 @@
if (dart.test(_isolate_helper._globalState.isWorker)) {
_isolate_helper._globalState.mainManager.postMessage(workerMessage);
} else {
- let manager = _isolate_helper._globalState.managers[dartx.get](this[_workerId]);
+ let manager = _isolate_helper._globalState.managers[dartx._get](this[_workerId]);
if (manager != null) {
manager.postMessage(workerMessage);
}
@@ -10617,10 +10616,10 @@
}
serialize(x) {
if (dart.test(this.isPrimitive(x))) return this.serializePrimitive(x);
- let serializationId = this.serializedObjectIds[dartx.get](x);
+ let serializationId = this.serializedObjectIds[dartx._get](x);
if (serializationId != null) return this.makeRef(serializationId);
serializationId = this.serializedObjectIds[dartx.length];
- this.serializedObjectIds[dartx.set](x, serializationId);
+ this.serializedObjectIds[dartx._set](x, serializationId);
if (_native_typed_data.NativeByteBuffer.is(x)) return this.serializeByteBuffer(x);
if (_native_typed_data.NativeTypedData.is(x)) return this.serializeTypedData(x);
if (_interceptors.JSIndexable.is(x)) return this.serializeJSIndexable(x);
@@ -10669,13 +10668,13 @@
let serialized = [];
serialized[dartx.length] = x[dartx.length];
for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
- serialized[dartx.set](i, this.serialize(x[dartx.get](i)));
+ serialized[dartx._set](i, this.serialize(x[dartx._get](i)));
}
return serialized;
}
serializeArrayInPlace(x) {
for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
- x[dartx.set](i, this.serialize(x[dartx.get](i)));
+ x[dartx._set](i, this.serialize(x[dartx._get](i)));
}
return x;
}
@@ -10691,7 +10690,7 @@
let values = [];
values[dartx.length] = keys[dartx.length];
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- values[dartx.set](i, this.serialize(x[keys[dartx.get](i)]));
+ values[dartx._set](i, this.serialize(x[keys[dartx._get](i)]));
}
return JSArrayOfObject().of(['js-object', keys, values]);
}
@@ -10830,7 +10829,7 @@
deserializeRef(x) {
dart.assert(dart.equals(dart.dindex(x, 0), 'ref'));
let serializationId = core.int._check(dart.dindex(x, 1));
- return this.deserializedObjects[dartx.get](serializationId);
+ return this.deserializedObjects[dartx._get](serializationId);
}
deserializeByteBuffer(x) {
dart.assert(dart.equals(dart.dindex(x, 0), 'buffer'));
@@ -10846,7 +10845,7 @@
}
deserializeArrayInPlace(x) {
for (let i = 0; i < dart.notNull(x[dartx.length]); i++) {
- x[dartx.set](i, this.deserialize(x[dartx.get](i)));
+ x[dartx._set](i, this.deserialize(x[dartx._get](i)));
}
return x;
}
@@ -10875,14 +10874,14 @@
return _interceptors.JSArray.markFixed(this.deserializeArrayInPlace(_interceptors.JSArray._check(result)));
}
deserializeMap(x) {
- dart.assert(dart.equals(x.get(0), 'map'));
- let keys = core.List._check(x.get(1));
- let values = core.List._check(x.get(2));
+ dart.assert(dart.equals(x._get(0), 'map'));
+ let keys = core.List._check(x._get(1));
+ let values = core.List._check(x._get(2));
let result = dart.map();
this.deserializedObjects[dartx.add](result);
keys = keys[dartx.map](dart.dynamic)(dart.bind(this, 'deserialize'))[dartx.toList]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- result[dartx.set](keys[dartx.get](i), this.deserialize(values[dartx.get](i)));
+ result[dartx._set](keys[dartx._get](i), this.deserialize(values[dartx._get](i)));
}
return result;
}
@@ -10893,7 +10892,7 @@
let receivePortId = core.int._check(dart.dindex(x, 3));
let result = null;
if (managerId == _isolate_helper._globalState.currentManagerId) {
- let isolate = _isolate_helper._globalState.isolates[dartx.get](isolateId);
+ let isolate = _isolate_helper._globalState.isolates[dartx._get](isolateId);
if (isolate == null) return null;
let receivePort = isolate.lookup(receivePortId);
if (receivePort == null) return null;
@@ -10917,7 +10916,7 @@
let o = {};
this.deserializedObjects[dartx.add](o);
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- o[keys[dartx.get](i)] = this.deserialize(values[dartx.get](i));
+ o[keys[dartx._get](i)] = this.deserialize(values[dartx._get](i));
}
return o;
}
@@ -11041,12 +11040,12 @@
if (match == null) {
return _js_helper.Primitives._parseIntError(source, handleError);
}
- let decimalMatch = match[dartx.get](decimalIndex);
+ let decimalMatch = match[dartx._get](decimalIndex);
if (radix == null) {
if (decimalMatch != null) {
return parseInt(source, 10);
}
- if (match[dartx.get](hexIndex) != null) {
+ if (match[dartx._get](hexIndex) != null) {
return parseInt(source, 16);
}
return _js_helper.Primitives._parseIntError(source, handleError);
@@ -11067,7 +11066,7 @@
} else {
maxCharCode = 97 - 10 - 1 + dart.notNull(radix);
}
- dart.assert(typeof match[dartx.get](digitsIndex) == 'string');
+ dart.assert(typeof match[dartx._get](digitsIndex) == 'string');
let digitsPart = match[digitsIndex];
for (let i = 0; i < dart.notNull(digitsPart[dartx.length]); i++) {
let characterCode = (dart.notNull(digitsPart[dartx.codeUnitAt](i)) | 32) >>> 0;
@@ -11205,11 +11204,11 @@
static getTimeZoneName(receiver) {
let d = _js_helper.Primitives.lazyAsJsDate(receiver);
let match = /\((.*)\)/.exec(d.toString());
- if (match != null) return core.String._check(match[dartx.get](1));
+ if (match != null) return core.String._check(match[dartx._get](1));
match = /^[A-Z,a-z]{3}\s[A-Z,a-z]{3}\s\d+\s\d{2}:\d{2}:\d{2}\s([A-Z]{3,5})\s\d{4}$/.exec(d.toString());
- if (match != null) return core.String._check(match[dartx.get](1));
+ if (match != null) return core.String._check(match[dartx._get](1));
match = /(?:GMT|UTC)[+-]\d{4}/.exec(d.toString());
- if (match != null) return core.String._check(match[dartx.get](0));
+ if (match != null) return core.String._check(match[dartx._get](0));
return "";
}
static getTimeZoneOffsetInMinutes(receiver) {
@@ -11561,7 +11560,7 @@
while (index < dart.notNull(length)) {
let key = _js_helper.getIndex(keyValuePairs, index++);
let value = _js_helper.getIndex(keyValuePairs, index++);
- result[dartx.set](key, value);
+ result[dartx._set](key, value);
}
return result;
};
@@ -11965,7 +11964,7 @@
return new (LinkedHashMapKeyIterableOfK())(this);
}
get values() {
- return MappedIterableOfK$V().new(this.keys, dart.fn(each => this.get(each), KToV()));
+ return MappedIterableOfK$V().new(this.keys, dart.fn(each => this._get(each), KToV()));
}
containsKey(key) {
if (dart.test(_js_helper.JsLinkedHashMap._isStringKey(key))) {
@@ -11987,15 +11986,15 @@
return dart.notNull(this.internalFindBucketIndex(bucket, key)) >= 0;
}
containsValue(value) {
- return this.keys[dartx.any](dart.fn(each => dart.equals(this.get(each), value), KTobool()));
+ return this.keys[dartx.any](dart.fn(each => dart.equals(this._get(each), value), KTobool()));
}
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
- get(key) {
+ _get(key) {
if (dart.test(_js_helper.JsLinkedHashMap._isStringKey(key))) {
let strings = this[_strings];
if (strings == null) return null;
@@ -12019,7 +12018,7 @@
let cell = bucket[index];
return cell.hashMapCellValue;
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
if (dart.test(_js_helper.JsLinkedHashMap._isStringKey(key))) {
@@ -12059,9 +12058,9 @@
putIfAbsent(key, ifAbsent) {
K._check(key);
VoidToV()._check(ifAbsent);
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
@@ -12234,9 +12233,9 @@
internalContainsKey: dart.definiteFunctionType(core.bool, [core.Object]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
- get: dart.definiteFunctionType(V, [core.Object]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
internalGet: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
internalSet: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
remove: dart.definiteFunctionType(V, [core.Object]),
@@ -12268,8 +12267,8 @@
'containsKey',
'containsValue',
'addAll',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -12556,7 +12555,7 @@
regexp.lastIndex = start;
let match = regexp.exec(string);
if (match == null) return null;
- if (match[dartx.get](dart.notNull(match[dartx.length]) - 1) != null) return null;
+ if (match[dartx._get](dart.notNull(match[dartx.length]) - 1) != null) return null;
match[dartx.length] = dart.notNull(match[dartx.length]) - 1;
return new _js_helper._MatchImplementation(this, ListOfString()._check(match));
}
@@ -12619,12 +12618,12 @@
return this[_match].index;
}
get end() {
- return dart.notNull(this.start) + dart.notNull(this[_match][dartx.get](0)[dartx.length]);
+ return dart.notNull(this.start) + dart.notNull(this[_match][dartx._get](0)[dartx.length]);
}
group(index) {
- return this[_match][dartx.get](index);
+ return this[_match][dartx._get](index);
}
- get(index) {
+ _get(index) {
return this.group(index);
}
get groupCount() {
@@ -12653,7 +12652,7 @@
}),
methods: () => ({
group: dart.definiteFunctionType(core.String, [core.int]),
- get: dart.definiteFunctionType(core.String, [core.int]),
+ _get: dart.definiteFunctionType(core.String, [core.int]),
groups: dart.definiteFunctionType(core.List$(core.String), [ListOfint()])
})
});
@@ -12755,7 +12754,7 @@
get end() {
return dart.notNull(this.start) + dart.notNull(this.pattern[dartx.length]);
}
- get(g) {
+ _get(g) {
return this.group(g);
}
get groupCount() {
@@ -12788,7 +12787,7 @@
groupCount: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(core.String, [core.int]),
+ _get: dart.definiteFunctionType(core.String, [core.int]),
group: dart.definiteFunctionType(core.String, [core.int]),
groups: dart.definiteFunctionType(core.List$(core.String), [ListOfint()])
})
@@ -12911,7 +12910,7 @@
let length = receiver[dartx.length];
result.write(replacement);
for (let i = 0; i < dart.notNull(length); i++) {
- result.write(receiver[dartx.get](i));
+ result.write(receiver[dartx._get](i));
result.write(replacement);
}
return result.toString();
@@ -12931,7 +12930,7 @@
};
dart.lazyFn(_js_helper.stringReplaceAllUnchecked, () => StringAndPatternAndStringToString());
_js_helper._matchString = function(match) {
- return match.get(0);
+ return match._get(0);
};
dart.lazyFn(_js_helper._matchString, () => MatchToString$());
_js_helper._stringIdentity = function(string) {
@@ -12974,7 +12973,7 @@
continue;
}
}
- buffer.write(onNonMatch(receiver[dartx.get](i)));
+ buffer.write(onNonMatch(receiver[dartx._get](i)));
i++;
}
buffer.write(onMatch(new _js_helper.StringMatch(i, receiver, "")));
@@ -13143,7 +13142,7 @@
let privateMembers = Object.getOwnPropertySymbols(data);
for (let member of core.Iterable._check(privateMembers)) {
let name = _js_mirrors._getNameForESSymbol(member);
- map[dartx.set](name, data[member]);
+ map[dartx._set](name, data[member]);
}
return map;
};
@@ -13430,13 +13429,13 @@
let constructors = _js_mirrors._getConstructors(unwrapped);
constructors[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
}, StringAnddynamicTovoid()));
if (dart.test(constructors[dartx.isEmpty])) {
let name = 'new';
let ft = _js_mirrors._defaultConstructorType(_js_mirrors._unwrap(this[_cls]));
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._constructor(this, name, ft));
}
let fields = _js_mirrors._getFields(unwrapped);
fields[dartx.forEach](dart.fn((name, t) => {
@@ -13446,23 +13445,23 @@
metadata = core.List._check(dart.dsend(dart.dsend(t, 'skip', 1), 'toList'));
t = dart.dindex(t, 0);
}
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
}, StringAnddynamicTovoid()));
let methods = _js_mirrors._getMethods(unwrapped);
methods[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let getters = _js_mirrors._getGetters(unwrapped);
getters[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let setters = _js_mirrors._getSetters(unwrapped);
setters[dartx.forEach](dart.fn((name, ft) => {
name = dart.notNull(name) + '=';
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._instanceMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let staticFields = _js_mirrors._getStaticFields(unwrapped);
staticFields[dartx.forEach](dart.fn((name, t) => {
@@ -13472,22 +13471,22 @@
metadata = core.List._check(dart.dsend(dart.dsend(t, 'skip', 1), 'toList'));
t = dart.dindex(t, 0);
}
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsVariableMirror._(name, core.Type._check(_js_mirrors._wrap(t)), metadata));
}, StringAnddynamicTovoid()));
let statics = _js_mirrors._getStatics(unwrapped);
statics[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let staticGetters = _js_mirrors._getStaticGetters(unwrapped);
staticGetters[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
}, StringAnddynamicTovoid()));
let staticSetters = _js_mirrors._getStaticSetters(unwrapped);
staticSetters[dartx.forEach](dart.fn((name, ft) => {
let symbol = core.Symbol.new(name);
- this[_declarations][dartx.set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
+ this[_declarations][dartx._set](symbol, new _js_mirrors.JsMethodMirror._staticMethod(this, name, ft));
}, StringAnddynamicTovoid()));
this[_declarations] = MapOfSymbol$DeclarationMirror().unmodifiable(this[_declarations]);
}
@@ -13799,16 +13798,16 @@
let opts = core.List._check(dart.dload(ftype, 'optionals'));
let params = ListOfParameterMirror().new(dart.notNull(args[dartx.length]) + dart.notNull(opts[dartx.length]));
for (let i = 0; i < dart.notNull(args[dartx.length]); ++i) {
- let type = args[dartx.get](i);
+ let type = args[dartx._get](i);
let metadata = dart.dindex(dart.dload(ftype, 'metadata'), i);
let param = new _js_mirrors.JsParameterMirror._('', core.Type._check(_js_mirrors._wrap(type)), core.List._check(metadata));
- params[dartx.set](i, param);
+ params[dartx._set](i, param);
}
for (let i = 0; i < dart.notNull(opts[dartx.length]); ++i) {
- let type = opts[dartx.get](i);
+ let type = opts[dartx._get](i);
let metadata = dart.dindex(dart.dload(ftype, 'metadata'), dart.notNull(args[dartx.length]) + i);
let param = new _js_mirrors.JsParameterMirror._('', core.Type._check(_js_mirrors._wrap(type)), core.List._check(metadata));
- params[dartx.set](i + dart.notNull(args[dartx.length]), param);
+ params[dartx._set](i + dart.notNull(args[dartx.length]), param);
}
this[_params] = ListOfParameterMirror().unmodifiable(params);
}
@@ -14642,11 +14641,11 @@
_slowFromList(list) {
this[_storage] = _native_typed_data.NativeFloat32List.new(dart.notNull(list[dartx.length]) * 4);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- let e = list[dartx.get](i);
- this[_storage][dartx.set](i * 4 + 0, e.x);
- this[_storage][dartx.set](i * 4 + 1, e.y);
- this[_storage][dartx.set](i * 4 + 2, e.z);
- this[_storage][dartx.set](i * 4 + 3, e.w);
+ let e = list[dartx._get](i);
+ this[_storage][dartx._set](i * 4 + 0, e.x);
+ this[_storage][dartx._set](i * 4 + 1, e.y);
+ this[_storage][dartx._set](i * 4 + 2, e.z);
+ this[_storage][dartx._set](i * 4 + 3, e.w);
}
}
get runtimeType() {
@@ -14677,20 +14676,20 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this.length);
- let _x = this[_storage][dartx.get](dart.notNull(index) * 4 + 0);
- let _y = this[_storage][dartx.get](dart.notNull(index) * 4 + 1);
- let _z = this[_storage][dartx.get](dart.notNull(index) * 4 + 2);
- let _w = this[_storage][dartx.get](dart.notNull(index) * 4 + 3);
+ let _x = this[_storage][dartx._get](dart.notNull(index) * 4 + 0);
+ let _y = this[_storage][dartx._get](dart.notNull(index) * 4 + 1);
+ let _z = this[_storage][dartx._get](dart.notNull(index) * 4 + 2);
+ let _w = this[_storage][dartx._get](dart.notNull(index) * 4 + 3);
return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this.length);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 0, value.x);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 1, value.y);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 2, value.z);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 3, value.w);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 0, value.x);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 1, value.y);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 2, value.z);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 3, value.w);
return value;
}
sublist(start, end) {
@@ -14718,14 +14717,14 @@
length: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(typed_data.Float32x4, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float32x4]),
+ _get: dart.definiteFunctionType(typed_data.Float32x4, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float32x4]),
sublist: dart.definiteFunctionType(core.List$(typed_data.Float32x4), [core.int], [core.int])
})
});
dart.defineExtensionMembers(_native_typed_data.NativeFloat32x4List, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sublist',
'buffer',
'lengthInBytes',
@@ -15275,11 +15274,11 @@
_slowFromList(list) {
this[_storage] = _native_typed_data.NativeInt32List.new(dart.notNull(list[dartx.length]) * 4);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- let e = list[dartx.get](i);
- this[_storage][dartx.set](i * 4 + 0, e.x);
- this[_storage][dartx.set](i * 4 + 1, e.y);
- this[_storage][dartx.set](i * 4 + 2, e.z);
- this[_storage][dartx.set](i * 4 + 3, e.w);
+ let e = list[dartx._get](i);
+ this[_storage][dartx._set](i * 4 + 0, e.x);
+ this[_storage][dartx._set](i * 4 + 1, e.y);
+ this[_storage][dartx._set](i * 4 + 2, e.z);
+ this[_storage][dartx._set](i * 4 + 3, e.w);
}
}
get runtimeType() {
@@ -15310,20 +15309,20 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this.length);
- let _x = this[_storage][dartx.get](dart.notNull(index) * 4 + 0);
- let _y = this[_storage][dartx.get](dart.notNull(index) * 4 + 1);
- let _z = this[_storage][dartx.get](dart.notNull(index) * 4 + 2);
- let _w = this[_storage][dartx.get](dart.notNull(index) * 4 + 3);
+ let _x = this[_storage][dartx._get](dart.notNull(index) * 4 + 0);
+ let _y = this[_storage][dartx._get](dart.notNull(index) * 4 + 1);
+ let _z = this[_storage][dartx._get](dart.notNull(index) * 4 + 2);
+ let _w = this[_storage][dartx._get](dart.notNull(index) * 4 + 3);
return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this.length);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 0, value.x);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 1, value.y);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 2, value.z);
- this[_storage][dartx.set](dart.notNull(index) * 4 + 3, value.w);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 0, value.x);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 1, value.y);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 2, value.z);
+ this[_storage][dartx._set](dart.notNull(index) * 4 + 3, value.w);
return value;
}
sublist(start, end) {
@@ -15351,14 +15350,14 @@
length: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Int32x4]),
+ _get: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Int32x4]),
sublist: dart.definiteFunctionType(core.List$(typed_data.Int32x4), [core.int], [core.int])
})
});
dart.defineExtensionMembers(_native_typed_data.NativeInt32x4List, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sublist',
'buffer',
'lengthInBytes',
@@ -15398,9 +15397,9 @@
_slowFromList(list) {
this[_storage] = _native_typed_data.NativeFloat64List.new(dart.notNull(list[dartx.length]) * 2);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- let e = list[dartx.get](i);
- this[_storage][dartx.set](i * 2 + 0, e.x);
- this[_storage][dartx.set](i * 2 + 1, e.y);
+ let e = list[dartx._get](i);
+ this[_storage][dartx._set](i * 2 + 0, e.x);
+ this[_storage][dartx._set](i * 2 + 1, e.y);
}
}
static fromList(list) {
@@ -15431,16 +15430,16 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this.length);
- let _x = this[_storage][dartx.get](dart.notNull(index) * 2 + 0);
- let _y = this[_storage][dartx.get](dart.notNull(index) * 2 + 1);
+ let _x = this[_storage][dartx._get](dart.notNull(index) * 2 + 0);
+ let _y = this[_storage][dartx._get](dart.notNull(index) * 2 + 1);
return typed_data.Float64x2.new(_x, _y);
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this.length);
- this[_storage][dartx.set](dart.notNull(index) * 2 + 0, value.x);
- this[_storage][dartx.set](dart.notNull(index) * 2 + 1, value.y);
+ this[_storage][dartx._set](dart.notNull(index) * 2 + 0, value.x);
+ this[_storage][dartx._set](dart.notNull(index) * 2 + 1, value.y);
return value;
}
sublist(start, end) {
@@ -15468,14 +15467,14 @@
length: dart.definiteFunctionType(core.int, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(typed_data.Float64x2, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float64x2]),
+ _get: dart.definiteFunctionType(typed_data.Float64x2, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, typed_data.Float64x2]),
sublist: dart.definiteFunctionType(core.List$(typed_data.Float64x2), [core.int], [core.int])
})
});
dart.defineExtensionMembers(_native_typed_data.NativeFloat64x2List, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sublist',
'buffer',
'lengthInBytes',
@@ -15552,7 +15551,7 @@
if (_interceptors.JSIndexable.is(list)) return list;
let result = core.List.new(list[dartx.length]);
for (let i = 0; i < dart.notNull(list[dartx.length]); i++) {
- result[dartx.set](i, list[dartx.get](i));
+ result[dartx._set](i, list[dartx._get](i));
}
return result;
};
@@ -15802,8 +15801,8 @@
});
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'setRange'
]);
_native_typed_data.NativeTypedArrayOfDouble = class NativeTypedArrayOfDouble extends dart.mixin(_native_typed_data.NativeTypedArray, collection.ListMixin$(core.double), _internal.FixedLengthListMixin$(core.double)) {
@@ -15813,11 +15812,11 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
this[index] = value;
return value;
@@ -15834,15 +15833,15 @@
dart.setSignature(_native_typed_data.NativeTypedArrayOfDouble, {
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
- get: dart.definiteFunctionType(core.double, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, core.num]),
+ _get: dart.definiteFunctionType(core.double, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, core.num]),
setRange: dart.definiteFunctionType(dart.void, [core.int, core.int, IterableOfdouble()], [core.int])
})
});
- dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfDouble, ['get', 'set', 'setRange', 'length']);
+ dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfDouble, ['_get', '_set', 'setRange', 'length']);
dart.defineExtensionNames([
'length',
- 'set',
+ '_set',
'setRange'
]);
_native_typed_data.NativeTypedArrayOfInt = class NativeTypedArrayOfInt extends dart.mixin(_native_typed_data.NativeTypedArray, collection.ListMixin$(core.int), _internal.FixedLengthListMixin$(core.int)) {
@@ -15852,7 +15851,7 @@
set length(value) {
super.length = value;
}
- set(index, value) {
+ _set(index, value) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
this[index] = value;
return value;
@@ -15870,11 +15869,11 @@
dart.setSignature(_native_typed_data.NativeTypedArrayOfInt, {
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
- set: dart.definiteFunctionType(dart.void, [core.int, core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, core.int]),
setRange: dart.definiteFunctionType(dart.void, [core.int, core.int, IterableOfint()], [core.int])
})
});
- dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfInt, ['set', 'setRange', 'length']);
+ dart.defineExtensionMembers(_native_typed_data.NativeTypedArrayOfInt, ['_set', 'setRange', 'length']);
dart.defineExtensionNames([
'runtimeType',
'sublist'
@@ -15977,7 +15976,7 @@
dart.registerExtension(dart.global.Float64Array, _native_typed_data.NativeFloat64List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeInt16List = class NativeInt16List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -15994,7 +15993,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Int16List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16022,7 +16021,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeInt16List, [_native_typed_data.NativeByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16035,7 +16034,7 @@
dart.registerExtension(dart.global.Int16Array, _native_typed_data.NativeInt16List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeInt32List = class NativeInt32List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16052,7 +16051,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Int32List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16080,7 +16079,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeInt32List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16093,7 +16092,7 @@
dart.registerExtension(dart.global.Int32Array, _native_typed_data.NativeInt32List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeInt8List = class NativeInt8List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16110,7 +16109,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Int8List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16138,7 +16137,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeInt8List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16151,7 +16150,7 @@
dart.registerExtension(dart.global.Int8Array, _native_typed_data.NativeInt8List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint16List = class NativeUint16List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16168,7 +16167,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Uint16List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16196,7 +16195,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint16List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16209,7 +16208,7 @@
dart.registerExtension(dart.global.Uint16Array, _native_typed_data.NativeUint16List);
dart.defineExtensionNames([
'runtimeType',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint32List = class NativeUint32List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16226,7 +16225,7 @@
get [dartx.runtimeType]() {
return dart.wrapType(typed_data.Uint32List);
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16254,7 +16253,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint32List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16268,7 +16267,7 @@
dart.defineExtensionNames([
'runtimeType',
'length',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint8ClampedList = class NativeUint8ClampedList extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16291,7 +16290,7 @@
set [dartx.length](value) {
super[dartx.length] = value;
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16319,7 +16318,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint8ClampedList, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16334,7 +16333,7 @@
dart.defineExtensionNames([
'runtimeType',
'length',
- 'get',
+ '_get',
'sublist'
]);
_native_typed_data.NativeUint8List = class NativeUint8List extends _native_typed_data.NativeTypedArrayOfInt {
@@ -16357,7 +16356,7 @@
set [dartx.length](value) {
super[dartx.length] = value;
}
- [dartx.get](index) {
+ [dartx._get](index) {
_native_typed_data._checkValidIndex(index, this, this[dartx.length]);
return this[index];
}
@@ -16385,7 +16384,7 @@
view: dart.definiteFunctionType(_native_typed_data.NativeUint8List, [typed_data.ByteBuffer, core.int, core.int])
}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.int, [core.int]),
+ [dartx._get]: dart.definiteFunctionType(core.int, [core.int]),
[dartx.sublist]: dart.definiteFunctionType(core.List$(core.int), [core.int], [core.int])
}),
statics: () => ({
@@ -16398,8 +16397,8 @@
dart.registerExtension(dart.global.Uint8Array, _native_typed_data.NativeUint8List);
_native_typed_data.NativeFloat32x4 = class NativeFloat32x4 extends core.Object {
static _truncate(x) {
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, core.num._check(x));
- return _native_typed_data.NativeFloat32x4._list[dartx.get](0);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, core.num._check(x));
+ return _native_typed_data.NativeFloat32x4._list[dartx._get](0);
}
new(x, y, z, w) {
this.x = core.double._check(_native_typed_data.NativeFloat32x4._truncate(x));
@@ -16418,11 +16417,11 @@
NativeFloat32x4.prototype._truncated.call(this, 0.0, 0.0, 0.0, 0.0);
}
static fromInt32x4Bits(i) {
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](0, i.x);
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](1, i.y);
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](2, i.z);
- _native_typed_data.NativeFloat32x4._uint32view[dartx.set](3, i.w);
- return new _native_typed_data.NativeFloat32x4._truncated(_native_typed_data.NativeFloat32x4._list[dartx.get](0), _native_typed_data.NativeFloat32x4._list[dartx.get](1), _native_typed_data.NativeFloat32x4._list[dartx.get](2), _native_typed_data.NativeFloat32x4._list[dartx.get](3));
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](0, i.x);
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](1, i.y);
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](2, i.z);
+ _native_typed_data.NativeFloat32x4._uint32view[dartx._set](3, i.w);
+ return new _native_typed_data.NativeFloat32x4._truncated(_native_typed_data.NativeFloat32x4._list[dartx._get](0), _native_typed_data.NativeFloat32x4._list[dartx._get](1), _native_typed_data.NativeFloat32x4._list[dartx._get](2), _native_typed_data.NativeFloat32x4._list[dartx._get](3));
}
fromFloat64x2(v) {
NativeFloat32x4.prototype._truncated.call(this, core.double._check(_native_typed_data.NativeFloat32x4._truncate(v.x)), core.double._check(_native_typed_data.NativeFloat32x4._truncate(v.y)), 0.0, 0.0);
@@ -16449,7 +16448,7 @@
let _w = dart.notNull(this.w) + dart.notNull(other.w);
return new _native_typed_data.NativeFloat32x4._doubles(_x, _y, _z, _w);
}
- ['unary-']() {
+ _negate() {
return new _native_typed_data.NativeFloat32x4._truncated(-dart.notNull(this.x), -dart.notNull(this.y), -dart.notNull(this.z), -dart.notNull(this.w));
}
['-'](other) {
@@ -16555,46 +16554,46 @@
get signMask() {
let view = _native_typed_data.NativeFloat32x4._uint32view;
let mx = null, my = null, mz = null, mw = null;
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, this.w);
- mx = (dart.notNull(view[dartx.get](0)) & 2147483648) >>> 31;
- my = (dart.notNull(view[dartx.get](1)) & 2147483648) >>> 30;
- mz = (dart.notNull(view[dartx.get](2)) & 2147483648) >>> 29;
- mw = (dart.notNull(view[dartx.get](3)) & 2147483648) >>> 28;
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, this.w);
+ mx = (dart.notNull(view[dartx._get](0)) & 2147483648) >>> 31;
+ my = (dart.notNull(view[dartx._get](1)) & 2147483648) >>> 30;
+ mz = (dart.notNull(view[dartx._get](2)) & 2147483648) >>> 29;
+ mw = (dart.notNull(view[dartx._get](3)) & 2147483648) >>> 28;
return core.int._check(dart.dsend(dart.dsend(dart.dsend(mx, '|', my), '|', mz), '|', mw));
}
shuffle(mask) {
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- let _z = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ let _z = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
}
shuffleMix(other, mask) {
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- _native_typed_data.NativeFloat32x4._list[dartx.set](0, other.x);
- _native_typed_data.NativeFloat32x4._list[dartx.set](1, other.y);
- _native_typed_data.NativeFloat32x4._list[dartx.set](2, other.z);
- _native_typed_data.NativeFloat32x4._list[dartx.set](3, other.w);
- let _z = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeFloat32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](0, other.x);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](1, other.y);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](2, other.z);
+ _native_typed_data.NativeFloat32x4._list[dartx._set](3, other.w);
+ let _z = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeFloat32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeFloat32x4._truncated(_x, _y, _z, _w);
}
withX(newX) {
@@ -16670,7 +16669,7 @@
getters: () => ({signMask: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
'+': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
- 'unary-': dart.definiteFunctionType(typed_data.Float32x4, []),
+ _negate: dart.definiteFunctionType(typed_data.Float32x4, []),
'-': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
'*': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
'/': dart.definiteFunctionType(typed_data.Float32x4, [typed_data.Float32x4]),
@@ -16712,8 +16711,8 @@
});
_native_typed_data.NativeInt32x4 = class NativeInt32x4 extends core.Object {
static _truncate(x) {
- _native_typed_data.NativeInt32x4._list[dartx.set](0, core.int._check(x));
- return _native_typed_data.NativeInt32x4._list[dartx.get](0);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, core.int._check(x));
+ return _native_typed_data.NativeInt32x4._list[dartx._get](0);
}
new(x, y, z, w) {
this.x = core.int._check(_native_typed_data.NativeInt32x4._truncate(x));
@@ -16733,12 +16732,12 @@
}
static fromFloat32x4Bits(f) {
let floatList = _native_typed_data.NativeFloat32x4._list;
- floatList[dartx.set](0, f.x);
- floatList[dartx.set](1, f.y);
- floatList[dartx.set](2, f.z);
- floatList[dartx.set](3, f.w);
+ floatList[dartx._set](0, f.x);
+ floatList[dartx._set](1, f.y);
+ floatList[dartx._set](2, f.z);
+ floatList[dartx._set](3, f.w);
let view = _native_typed_data.NativeInt32List._check(floatList[dartx.buffer][dartx.asInt32List]());
- return new _native_typed_data.NativeInt32x4._truncated(view[dartx.get](0), view[dartx.get](1), view[dartx.get](2), view[dartx.get](3));
+ return new _native_typed_data.NativeInt32x4._truncated(view[dartx._get](0), view[dartx._get](1), view[dartx._get](2), view[dartx._get](3));
}
_truncated(x, y, z, w) {
this.x = x;
@@ -16764,7 +16763,7 @@
['-'](other) {
return new _native_typed_data.NativeInt32x4._truncated(this.x - other.x | 0, this.y - other.y | 0, this.z - other.z | 0, this.w - other.w | 0);
}
- ['unary-']() {
+ _negate() {
return new _native_typed_data.NativeInt32x4._truncated(-this.x | 0, -this.y | 0, -this.z | 0, -this.w | 0);
}
get signMask() {
@@ -16778,32 +16777,32 @@
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeInt32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeInt32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeInt32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeInt32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- let _z = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeInt32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeInt32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeInt32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ let _z = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
}
shuffleMix(other, mask) {
if (dart.notNull(mask) < 0 || dart.notNull(mask) > 255) {
dart.throw(new core.RangeError.range(mask, 0, 255, "mask"));
}
- _native_typed_data.NativeInt32x4._list[dartx.set](0, this.x);
- _native_typed_data.NativeInt32x4._list[dartx.set](1, this.y);
- _native_typed_data.NativeInt32x4._list[dartx.set](2, this.z);
- _native_typed_data.NativeInt32x4._list[dartx.set](3, this.w);
- let _x = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) & 3);
- let _y = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 2 & 3);
- _native_typed_data.NativeInt32x4._list[dartx.set](0, other.x);
- _native_typed_data.NativeInt32x4._list[dartx.set](1, other.y);
- _native_typed_data.NativeInt32x4._list[dartx.set](2, other.z);
- _native_typed_data.NativeInt32x4._list[dartx.set](3, other.w);
- let _z = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 4 & 3);
- let _w = _native_typed_data.NativeInt32x4._list[dartx.get](dart.notNull(mask) >> 6 & 3);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, this.x);
+ _native_typed_data.NativeInt32x4._list[dartx._set](1, this.y);
+ _native_typed_data.NativeInt32x4._list[dartx._set](2, this.z);
+ _native_typed_data.NativeInt32x4._list[dartx._set](3, this.w);
+ let _x = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) & 3);
+ let _y = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 2 & 3);
+ _native_typed_data.NativeInt32x4._list[dartx._set](0, other.x);
+ _native_typed_data.NativeInt32x4._list[dartx._set](1, other.y);
+ _native_typed_data.NativeInt32x4._list[dartx._set](2, other.z);
+ _native_typed_data.NativeInt32x4._list[dartx._set](3, other.w);
+ let _z = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 4 & 3);
+ let _w = _native_typed_data.NativeInt32x4._list[dartx._get](dart.notNull(mask) >> 6 & 3);
return new _native_typed_data.NativeInt32x4._truncated(_x, _y, _z, _w);
}
withX(x) {
@@ -16853,31 +16852,31 @@
select(trueValue, falseValue) {
let floatList = _native_typed_data.NativeFloat32x4._list;
let intView = _native_typed_data.NativeFloat32x4._uint32view;
- floatList[dartx.set](0, trueValue.x);
- floatList[dartx.set](1, trueValue.y);
- floatList[dartx.set](2, trueValue.z);
- floatList[dartx.set](3, trueValue.w);
- let stx = intView[dartx.get](0);
- let sty = intView[dartx.get](1);
- let stz = intView[dartx.get](2);
- let stw = intView[dartx.get](3);
- floatList[dartx.set](0, falseValue.x);
- floatList[dartx.set](1, falseValue.y);
- floatList[dartx.set](2, falseValue.z);
- floatList[dartx.set](3, falseValue.w);
- let sfx = intView[dartx.get](0);
- let sfy = intView[dartx.get](1);
- let sfz = intView[dartx.get](2);
- let sfw = intView[dartx.get](3);
+ floatList[dartx._set](0, trueValue.x);
+ floatList[dartx._set](1, trueValue.y);
+ floatList[dartx._set](2, trueValue.z);
+ floatList[dartx._set](3, trueValue.w);
+ let stx = intView[dartx._get](0);
+ let sty = intView[dartx._get](1);
+ let stz = intView[dartx._get](2);
+ let stw = intView[dartx._get](3);
+ floatList[dartx._set](0, falseValue.x);
+ floatList[dartx._set](1, falseValue.y);
+ floatList[dartx._set](2, falseValue.z);
+ floatList[dartx._set](3, falseValue.w);
+ let sfx = intView[dartx._get](0);
+ let sfy = intView[dartx._get](1);
+ let sfz = intView[dartx._get](2);
+ let sfw = intView[dartx._get](3);
let _x = (dart.notNull(this.x) & dart.notNull(stx) | ~dart.notNull(this.x) & dart.notNull(sfx)) >>> 0;
let _y = (dart.notNull(this.y) & dart.notNull(sty) | ~dart.notNull(this.y) & dart.notNull(sfy)) >>> 0;
let _z = (dart.notNull(this.z) & dart.notNull(stz) | ~dart.notNull(this.z) & dart.notNull(sfz)) >>> 0;
let _w = (dart.notNull(this.w) & dart.notNull(stw) | ~dart.notNull(this.w) & dart.notNull(sfw)) >>> 0;
- intView[dartx.set](0, _x);
- intView[dartx.set](1, _y);
- intView[dartx.set](2, _z);
- intView[dartx.set](3, _w);
- return new _native_typed_data.NativeFloat32x4._truncated(floatList[dartx.get](0), floatList[dartx.get](1), floatList[dartx.get](2), floatList[dartx.get](3));
+ intView[dartx._set](0, _x);
+ intView[dartx._set](1, _y);
+ intView[dartx._set](2, _z);
+ intView[dartx._set](3, _w);
+ return new _native_typed_data.NativeFloat32x4._truncated(floatList[dartx._get](0), floatList[dartx._get](1), floatList[dartx._get](2), floatList[dartx._get](3));
}
};
dart.defineNamedConstructor(_native_typed_data.NativeInt32x4, 'bool');
@@ -16909,7 +16908,7 @@
'^': dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4]),
'+': dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4]),
'-': dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4]),
- 'unary-': dart.definiteFunctionType(typed_data.Int32x4, []),
+ _negate: dart.definiteFunctionType(typed_data.Int32x4, []),
shuffle: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
shuffleMix: dart.definiteFunctionType(typed_data.Int32x4, [typed_data.Int32x4, core.int]),
withX: dart.definiteFunctionType(typed_data.Int32x4, [core.int]),
@@ -16957,7 +16956,7 @@
['+'](other) {
return new _native_typed_data.NativeFloat64x2._doubles(dart.notNull(this.x) + dart.notNull(other.x), dart.notNull(this.y) + dart.notNull(other.y));
}
- ['unary-']() {
+ _negate() {
return new _native_typed_data.NativeFloat64x2._doubles(-dart.notNull(this.x), -dart.notNull(this.y));
}
['-'](other) {
@@ -16990,10 +16989,10 @@
}
get signMask() {
let view = _native_typed_data.NativeFloat64x2._uint32View;
- _native_typed_data.NativeFloat64x2._list[dartx.set](0, this.x);
- _native_typed_data.NativeFloat64x2._list[dartx.set](1, this.y);
- let mx = (dart.notNull(view[dartx.get](1)) & 2147483648) >>> 31;
- let my = (dart.notNull(view[dartx.get](3)) & 2147483648) >>> 31;
+ _native_typed_data.NativeFloat64x2._list[dartx._set](0, this.x);
+ _native_typed_data.NativeFloat64x2._list[dartx._set](1, this.y);
+ let mx = (dart.notNull(view[dartx._get](1)) & 2147483648) >>> 31;
+ let my = (dart.notNull(view[dartx._get](3)) & 2147483648) >>> 31;
return (mx | my << 1) >>> 0;
}
withX(x) {
@@ -17034,7 +17033,7 @@
getters: () => ({signMask: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
'+': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
- 'unary-': dart.definiteFunctionType(typed_data.Float64x2, []),
+ _negate: dart.definiteFunctionType(typed_data.Float64x2, []),
'-': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
'*': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
'/': dart.definiteFunctionType(typed_data.Float64x2, [typed_data.Float64x2]),
@@ -18401,7 +18400,7 @@
future.then(dart.dynamic)(dart.fn(value => {
remaining--;
if (values != null) {
- values[dartx.set](pos, value);
+ values[dartx._set](pos, value);
if (remaining == 0) {
result[_completeWithValue](values);
}
@@ -22426,13 +22425,13 @@
}
};
}
- get(key) {
- let result = this[_map$][dartx.get](key);
+ _get(key) {
+ let result = this[_map$][dartx._get](key);
if (result != null || dart.test(this[_map$][dartx.containsKey](key))) return result;
if (this.parent != null) {
- let value = this.parent.get(key);
+ let value = this.parent._get(key);
if (value != null) {
- this[_map$][dartx.set](key, value);
+ this[_map$][dartx._set](key, value);
}
return value;
}
@@ -22580,7 +22579,7 @@
bindCallback: dart.definiteFunctionType(R => [async.ZoneCallback$(R), [dart.functionType(R, [])], {runGuarded: core.bool}]),
bindUnaryCallback: dart.definiteFunctionType((R, T) => [async.ZoneUnaryCallback$(R, T), [dart.functionType(R, [T])], {runGuarded: core.bool}]),
bindBinaryCallback: dart.definiteFunctionType((R, T1, T2) => [async.ZoneBinaryCallback$(R, T1, T2), [dart.functionType(R, [T1, T2])], {runGuarded: core.bool}]),
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
handleUncaughtError: dart.definiteFunctionType(R => [R, [dart.dynamic, core.StackTrace]]),
fork: dart.definiteFunctionType(async.Zone, [], {specification: async.ZoneSpecification, zoneValues: core.Map}),
run: dart.definiteFunctionType(R => [R, [dart.functionType(R, [])]]),
@@ -22862,7 +22861,7 @@
}
};
}
- get(key) {
+ _get(key) {
return null;
}
handleUncaughtError(R) {
@@ -22952,7 +22951,7 @@
bindCallback: dart.definiteFunctionType(R => [async.ZoneCallback$(R), [dart.functionType(R, [])], {runGuarded: core.bool}]),
bindUnaryCallback: dart.definiteFunctionType((R, T) => [async.ZoneUnaryCallback$(R, T), [dart.functionType(R, [T])], {runGuarded: core.bool}]),
bindBinaryCallback: dart.definiteFunctionType((R, T1, T2) => [async.ZoneBinaryCallback$(R, T1, T2), [dart.functionType(R, [T1, T2])], {runGuarded: core.bool}]),
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
handleUncaughtError: dart.definiteFunctionType(R => [R, [dart.dynamic, core.StackTrace]]),
fork: dart.definiteFunctionType(async.Zone, [], {specification: async.ZoneSpecification, zoneValues: core.Map}),
run: dart.definiteFunctionType(R => [R, [dart.functionType(R, [])]]),
@@ -23066,7 +23065,7 @@
return new (_HashMapKeyIterableOfK())(this);
}
get values() {
- return MappedIterableOfK$V().new(this.keys, dart.fn(each => this.get(each), KToV()));
+ return MappedIterableOfK$V().new(this.keys, dart.fn(each => this._get(each), KToV()));
}
containsKey(key) {
if (dart.test(collection._HashMap._isStringKey(key))) {
@@ -23086,15 +23085,15 @@
return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
}
containsValue(value) {
- return this[_computeKeys]()[dartx.any](dart.fn(each => dart.equals(this.get(each), value), KTobool()));
+ return this[_computeKeys]()[dartx.any](dart.fn(each => dart.equals(this._get(each), value), KTobool()));
}
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
- get(key) {
+ _get(key) {
if (dart.test(collection._HashMap._isStringKey(key))) {
let strings = this[_strings$];
return V._check(strings == null ? null : collection._HashMap._getTableEntry(strings, key));
@@ -23112,7 +23111,7 @@
let index = this[_findBucketIndex](bucket, key);
return V._check(dart.notNull(index) < 0 ? null : bucket[dart.notNull(index) + 1]);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
if (dart.test(collection._HashMap._isStringKey(key))) {
@@ -23153,9 +23152,9 @@
putIfAbsent(key, ifAbsent) {
K._check(key);
VoidToV()._check(ifAbsent);
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
@@ -23187,7 +23186,7 @@
let keys = this[_computeKeys]();
for (let i = 0, length = keys[dartx.length]; i < dart.notNull(length); i++) {
let key = keys[i];
- action(K._check(key), this.get(key));
+ action(K._check(key), this._get(key));
if (keys !== this[_keys]) {
dart.throw(new core.ConcurrentModificationError(this));
}
@@ -23325,9 +23324,9 @@
[_containsKey]: dart.definiteFunctionType(core.bool, [core.Object]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
- get: dart.definiteFunctionType(V, [core.Object]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
[_get]: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
[_set]: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
remove: dart.definiteFunctionType(V, [core.Object]),
@@ -23356,8 +23355,8 @@
'containsKey',
'containsValue',
'addAll',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -23404,11 +23403,11 @@
this[_validKey] = validKey != null ? validKey : dart.fn(v => K.is(v), ObjectTobool());
super.new();
}
- get(key) {
+ _get(key) {
if (!dart.test(this[_validKey](key))) return null;
return super[_get](key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
super[_set](key, value);
@@ -23445,12 +23444,12 @@
[_validKey]: _PredicateOfObject()
}),
methods: () => ({
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
remove: dart.definiteFunctionType(V, [core.Object])
})
});
- dart.defineExtensionMembers(_CustomHashMap, ['get', 'set', 'containsKey', 'remove']);
+ dart.defineExtensionMembers(_CustomHashMap, ['_get', '_set', 'containsKey', 'remove']);
return _CustomHashMap;
});
collection._CustomHashMap = _CustomHashMap();
@@ -23627,13 +23626,13 @@
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
- get(key) {
+ _get(key) {
return this[_map$0].get(key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
this[_map$0].set(key, value);
@@ -23643,13 +23642,13 @@
putIfAbsent(key, ifAbsent) {
K._check(key);
VoidToV()._check(ifAbsent);
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
- let value = this.get(key);
+ let value = this._get(key);
this[_map$0].delete(key);
this[_modified$]();
return value;
@@ -23694,8 +23693,8 @@
}),
methods: () => ({
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
remove: dart.definiteFunctionType(V, [core.Object]),
forEach: dart.definiteFunctionType(dart.void, [KAndVTovoid()]),
@@ -23706,8 +23705,8 @@
'containsKey',
'containsValue',
'addAll',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -23853,11 +23852,11 @@
this[_validKey] = validKey != null ? validKey : dart.fn(v => K.is(v), ObjectTobool());
super.new();
}
- get(key) {
+ _get(key) {
if (!dart.test(this[_validKey](key))) return null;
return super.internalGet(key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
super.internalSet(key, value);
@@ -23892,12 +23891,12 @@
[_validKey]: _PredicateOfObject()
}),
methods: () => ({
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
remove: dart.definiteFunctionType(V, [core.Object])
})
});
- dart.defineExtensionMembers(_LinkedCustomHashMap, ['get', 'set', 'containsKey', 'remove']);
+ dart.defineExtensionMembers(_LinkedCustomHashMap, ['_get', '_set', 'containsKey', 'remove']);
return _LinkedCustomHashMap;
});
collection._LinkedCustomHashMap = _LinkedCustomHashMap();
@@ -23998,7 +23997,7 @@
})() : ListOfE().new(this.length);
let i = 0;
for (let element of this)
- result[dartx.set](i++, element);
+ result[dartx._set](i++, element);
return result;
}
map(T) {
@@ -24334,7 +24333,7 @@
let bucket = this[_getBucket$](rest, object);
let index = this[_findBucketIndex](bucket, object);
if (dart.notNull(index) < 0) return null;
- return bucket[dartx.get](index);
+ return bucket[dartx._get](index);
}
add(element) {
E._check(element);
@@ -24760,7 +24759,7 @@
let bucket = this[_getBucket$](rest, object);
let index = this[_findBucketIndex](bucket, object);
if (dart.notNull(index) < 0) return null;
- return bucket[dartx.get](index)[_element];
+ return bucket[dartx._get](index)[_element];
}
forEach(action) {
let cell = this[_first$];
@@ -25192,7 +25191,7 @@
set length(value) {
super.length = value;
}
- get(index) {
+ _get(index) {
return this[_source$0][dartx.elementAt](index);
}
}
@@ -25200,9 +25199,9 @@
constructors: () => ({new: dart.definiteFunctionType(collection.UnmodifiableListView$(E), [IterableOfE()])}),
fields: () => ({[_source$0]: IterableOfE()}),
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
- methods: () => ({get: dart.definiteFunctionType(E, [core.int])})
+ methods: () => ({_get: dart.definiteFunctionType(E, [core.int])})
});
- dart.defineExtensionMembers(UnmodifiableListView, ['get', 'length']);
+ dart.defineExtensionMembers(UnmodifiableListView, ['_get', 'length']);
return UnmodifiableListView;
});
collection.UnmodifiableListView = UnmodifiableListView();
@@ -25271,7 +25270,7 @@
static from(other) {
let result = HashMapOfK$V().new();
other[dartx.forEach](dart.fn((k, v) => {
- result.set(K.as(k), V.as(v));
+ result._set(K.as(k), V.as(v));
}, dynamicAnddynamicTovoid$()));
return result;
}
@@ -25641,7 +25640,7 @@
});
collection._isToStringVisiting = function(o) {
for (let i = 0; i < dart.notNull(collection._toStringVisiting[dartx.length]); i++) {
- if (core.identical(o, collection._toStringVisiting[dartx.get](i))) return true;
+ if (core.identical(o, collection._toStringVisiting[dartx._get](i))) return true;
}
return false;
};
@@ -25823,7 +25822,7 @@
static from(other) {
let result = LinkedHashMapOfK$V().new();
other[dartx.forEach](dart.fn((k, v) => {
- result.set(K.as(k), V.as(v));
+ result._set(K.as(k), V.as(v));
}, dynamicAnddynamicTovoid$()));
return result;
}
@@ -26190,18 +26189,18 @@
class MapMixin extends core.Object {
forEach(action) {
for (let key of this.keys) {
- action(key, this.get(key));
+ action(key, this._get(key));
}
}
addAll(other) {
MapOfK$V()._check(other);
for (let key of other[dartx.keys]) {
- this.set(key, other[dartx.get](key));
+ this._set(key, other[dartx._get](key));
}
}
containsValue(value) {
for (let key of this.keys) {
- if (dart.equals(this.get(key), value)) return true;
+ if (dart.equals(this._get(key), value)) return true;
}
return false;
}
@@ -26209,9 +26208,9 @@
K._check(key);
VoidToV()._check(ifAbsent);
if (dart.test(this.containsKey(key))) {
- return this.get(key);
+ return this._get(key);
}
- return this.set(key, ifAbsent());
+ return this._set(key, ifAbsent());
}
containsKey(key) {
return this.keys[dartx.contains](key);
@@ -26272,7 +26271,7 @@
let MapOfK$V = () => (MapOfK$V = dart.constFn(core.Map$(K, V)))();
let VoidToV = () => (VoidToV = dart.constFn(dart.functionType(V, [])))();
class _UnmodifiableMapMixin extends core.Object {
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
@@ -26298,7 +26297,7 @@
_UnmodifiableMapMixin[dart.implements] = () => [MapOfK$V()];
dart.setSignature(_UnmodifiableMapMixin, {
methods: () => ({
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
clear: dart.definiteFunctionType(dart.void, []),
remove: dart.definiteFunctionType(V, [core.Object]),
@@ -26306,7 +26305,7 @@
})
});
dart.defineExtensionMembers(_UnmodifiableMapMixin, [
- 'set',
+ '_set',
'addAll',
'clear',
'remove',
@@ -26342,13 +26341,13 @@
return this[_map$0][dartx.isNotEmpty];
}
get first() {
- return this[_map$0][dartx.get](this[_map$0][dartx.keys][dartx.first]);
+ return this[_map$0][dartx._get](this[_map$0][dartx.keys][dartx.first]);
}
get single() {
- return this[_map$0][dartx.get](this[_map$0][dartx.keys][dartx.single]);
+ return this[_map$0][dartx._get](this[_map$0][dartx.keys][dartx.single]);
}
get last() {
- return this[_map$0][dartx.get](this[_map$0][dartx.keys][dartx.last]);
+ return this[_map$0][dartx._get](this[_map$0][dartx.keys][dartx.last]);
}
get iterator() {
return new (_MapBaseValueIteratorOfK$V())(this[_map$0]);
@@ -26389,7 +26388,7 @@
}
moveNext() {
if (dart.test(this[_keys].moveNext())) {
- this[_current$2] = this[_map$0][dartx.get](this[_keys].current);
+ this[_current$2] = this[_map$0][dartx._get](this[_keys].current);
return true;
}
this[_current$2] = null;
@@ -26422,13 +26421,13 @@
new(map) {
this[_map$0] = map;
}
- get(key) {
- return this[_map$0][dartx.get](key);
+ _get(key) {
+ return this[_map$0][dartx._get](key);
}
- set(key, value) {
+ _set(key, value) {
K._check(key);
V._check(value);
- this[_map$0][dartx.set](key, value);
+ this[_map$0][dartx._set](key, value);
return value;
}
addAll(other) {
@@ -26487,8 +26486,8 @@
values: dart.definiteFunctionType(core.Iterable$(V), [])
}),
methods: () => ({
- get: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
clear: dart.definiteFunctionType(dart.void, []),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
@@ -26499,8 +26498,8 @@
})
});
dart.defineExtensionMembers(MapView, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'addAll',
'clear',
'putIfAbsent',
@@ -26545,10 +26544,10 @@
}
static putIfAbsent(map, key, ifAbsent) {
if (dart.test(map[dartx.containsKey](key))) {
- return map[dartx.get](key);
+ return map[dartx._get](key);
}
let v = ifAbsent();
- map[dartx.set](key, v);
+ map[dartx._set](key, v);
return v;
}
static clear(map) {
@@ -26558,11 +26557,11 @@
}
static forEach(map, f) {
for (let k of map[dartx.keys]) {
- dart.dcall(f, k, map[dartx.get](k));
+ dart.dcall(f, k, map[dartx._get](k));
}
}
static getValues(map) {
- return map[dartx.keys][dartx.map](dart.dynamic)(dart.fn(key => map[dartx.get](key), dynamicTodynamic$()));
+ return map[dartx.keys][dartx.map](dart.dynamic)(dart.fn(key => map[dartx._get](key), dynamicTodynamic$()));
}
static length(map) {
return map[dartx.keys][dartx.length];
@@ -26605,7 +26604,7 @@
if (key == null) key = collection.Maps._id;
if (value == null) value = collection.Maps._id;
for (let element of iterable) {
- map[dartx.set](dart.dcall(key, element), dart.dcall(value, element));
+ map[dartx._set](dart.dcall(key, element), dart.dcall(value, element));
}
}
static _fillMapWithIterables(map, keys, values) {
@@ -26614,7 +26613,7 @@
let hasNextKey = keyIterator.moveNext();
let hasNextValue = valueIterator.moveNext();
while (dart.test(hasNextKey) && dart.test(hasNextValue)) {
- map[dartx.set](keyIterator.current, valueIterator.current);
+ map[dartx._set](keyIterator.current, valueIterator.current);
hasNextKey = keyIterator.moveNext();
hasNextValue = valueIterator.moveNext();
}
@@ -27153,7 +27152,7 @@
let queue = new (ListQueueOfE())(dart.notNull(length) + 1);
dart.assert(dart.notNull(queue[_table][dartx.length]) > dart.notNull(length));
for (let i = 0; i < dart.notNull(length); i++) {
- queue[_table][dartx.set](i, E.as(elements[dartx.get](i)));
+ queue[_table][dartx._set](i, E.as(elements[dartx._get](i)));
}
queue[_tail] = length;
return queue;
@@ -27175,7 +27174,7 @@
forEach(action) {
let modificationCount = this[_modificationCount];
for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0) {
- action(this[_table][dartx.get](i));
+ action(this[_table][dartx._get](i));
this[_checkModification](modificationCount);
}
}
@@ -27187,20 +27186,20 @@
}
get first() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
- return this[_table][dartx.get](this[_head]);
+ return this[_table][dartx._get](this[_head]);
}
get last() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
- return this[_table][dartx.get]((dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
+ return this[_table][dartx._get]((dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
}
get single() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
if (dart.notNull(this.length) > 1) dart.throw(_internal.IterableElementError.tooMany());
- return this[_table][dartx.get](this[_head]);
+ return this[_table][dartx._get](this[_head]);
}
elementAt(index) {
core.RangeError.checkValidIndex(index, this);
- return this[_table][dartx.get]((dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
+ return this[_table][dartx._get]((dart.notNull(this[_head]) + dart.notNull(index) & dart.notNull(this[_table][dartx.length]) - 1) >>> 0);
}
toList(opts) {
let growable = opts && 'growable' in opts ? opts.growable : true;
@@ -27248,7 +27247,7 @@
}
remove(value) {
for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0) {
- let element = this[_table][dartx.get](i);
+ let element = this[_table][dartx._get](i);
if (dart.equals(element, value)) {
this[_remove](i);
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ -27261,7 +27260,7 @@
let modificationCount = this[_modificationCount];
let i = this[_head];
while (i != this[_tail]) {
- let element = this[_table][dartx.get](i);
+ let element = this[_table][dartx._get](i);
let remove = core.identical(removeMatching, test(element));
this[_checkModification](modificationCount);
if (remove) {
@@ -27281,7 +27280,7 @@
clear() {
if (this[_head] != this[_tail]) {
for (let i = this[_head]; i != this[_tail]; i = (dart.notNull(i) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0) {
- this[_table][dartx.set](i, null);
+ this[_table][dartx._set](i, null);
}
this[_head] = this[_tail] = 0;
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ -27297,15 +27296,15 @@
addFirst(value) {
E._check(value);
this[_head] = (dart.notNull(this[_head]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
- this[_table][dartx.set](this[_head], value);
+ this[_table][dartx._set](this[_head], value);
if (this[_head] == this[_tail]) this[_grow]();
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
}
removeFirst() {
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
- let result = this[_table][dartx.get](this[_head]);
- this[_table][dartx.set](this[_head], null);
+ let result = this[_table][dartx._get](this[_head]);
+ this[_table][dartx._set](this[_head], null);
this[_head] = (dart.notNull(this[_head]) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
return result;
}
@@ -27313,8 +27312,8 @@
if (this[_head] == this[_tail]) dart.throw(_internal.IterableElementError.noElement());
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
this[_tail] = (dart.notNull(this[_tail]) - 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
- let result = this[_table][dartx.get](this[_tail]);
- this[_table][dartx.set](this[_tail], null);
+ let result = this[_table][dartx._get](this[_tail]);
+ this[_table][dartx._set](this[_tail], null);
return result;
}
static _isPowerOf2(number) {
@@ -27336,7 +27335,7 @@
}
[_add$0](element) {
E._check(element);
- this[_table][dartx.set](this[_tail], element);
+ this[_table][dartx._set](this[_tail], element);
this[_tail] = (dart.notNull(this[_tail]) + 1 & dart.notNull(this[_table][dartx.length]) - 1) >>> 0;
if (this[_head] == this[_tail]) this[_grow]();
this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
@@ -27349,10 +27348,10 @@
let i = offset;
while (i != this[_head]) {
let prevOffset = (dart.notNull(i) - 1 & mask) >>> 0;
- this[_table][dartx.set](i, this[_table][dartx.get](prevOffset));
+ this[_table][dartx._set](i, this[_table][dartx._get](prevOffset));
i = prevOffset;
}
- this[_table][dartx.set](this[_head], null);
+ this[_table][dartx._set](this[_head], null);
this[_head] = (dart.notNull(this[_head]) + 1 & mask) >>> 0;
return (dart.notNull(offset) + 1 & mask) >>> 0;
} else {
@@ -27360,10 +27359,10 @@
let i = offset;
while (i != this[_tail]) {
let nextOffset = (dart.notNull(i) + 1 & mask) >>> 0;
- this[_table][dartx.set](i, this[_table][dartx.get](nextOffset));
+ this[_table][dartx._set](i, this[_table][dartx._get](nextOffset));
i = nextOffset;
}
- this[_table][dartx.set](this[_tail], null);
+ this[_table][dartx._set](this[_tail], null);
return offset;
}
}
@@ -27485,7 +27484,7 @@
this[_current$2] = null;
return false;
}
- this[_current$2] = this[_queue][_table][dartx.get](this[_position]);
+ this[_current$2] = this[_queue][_table][dartx._get](this[_position]);
this[_position] = (dart.notNull(this[_position]) + 1 & dart.notNull(this[_queue][_table][dartx.length]) - 1) >>> 0;
return true;
}
@@ -27760,7 +27759,7 @@
if (isValidKey === void 0) isValidKey = null;
let result = new (SplayTreeMapOfK$V())(compare, isValidKey);
other[dartx.forEach](dart.fn((k, v) => {
- result.set(K.as(k), V.as(v));
+ result._set(K.as(k), V.as(v));
}, dynamicAnddynamicTovoid$()));
return result;
}
@@ -27792,7 +27791,7 @@
this[_validKey] = null;
super.new();
}
- get(key) {
+ _get(key) {
if (!dart.test(dart.dcall(this[_validKey], key))) return null;
if (this[_root] != null) {
let comp = this[_splay](K.as(key));
@@ -27808,7 +27807,7 @@
if (mapRoot != null) return mapRoot.value;
return null;
}
- set(key, value) {
+ _set(key, value) {
(() => {
K._check(key);
V._check(value);
@@ -27846,7 +27845,7 @@
addAll(other) {
MapOfK$V()._check(other);
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, KAndVTovoid$()));
}
get isEmpty() {
@@ -27957,9 +27956,9 @@
}),
methods: () => ({
[_compare]: dart.definiteFunctionType(core.int, [K, K]),
- get: dart.definiteFunctionType(V, [core.Object]),
+ _get: dart.definiteFunctionType(V, [core.Object]),
remove: dart.definiteFunctionType(V, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [K, V]),
+ _set: dart.definiteFunctionType(dart.void, [K, V]),
putIfAbsent: dart.definiteFunctionType(V, [K, VoidToV()]),
addAll: dart.definiteFunctionType(dart.void, [MapOfK$V()]),
forEach: dart.definiteFunctionType(dart.void, [KAndVTovoid()]),
@@ -27973,9 +27972,9 @@
})
});
dart.defineExtensionMembers(SplayTreeMap, [
- 'get',
+ '_get',
'remove',
- 'set',
+ '_set',
'putIfAbsent',
'addAll',
'forEach',
@@ -28450,7 +28449,7 @@
let processed = map[_processed];
let keys = map[_computeKeys$]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
+ let key = keys[dartx._get](i);
let revived = dart.dcall(reviver, key, walk(e[key]));
processed[key] = revived;
}
@@ -28487,9 +28486,9 @@
this[_original] = original;
this[_data] = null;
}
- get(key) {
+ _get(key) {
if (dart.test(this[_isUpgraded])) {
- return this[_upgradedMap][dartx.get](key);
+ return this[_upgradedMap][dartx._get](key);
} else if (!(typeof key == 'string')) {
return null;
} else {
@@ -28513,11 +28512,11 @@
}
get values() {
if (dart.test(this[_isUpgraded])) return this[_upgradedMap][dartx.values];
- return MappedIterableOfString$dynamic().new(this[_computeKeys$](), dart.fn(each => this.get(each), dynamicTodynamic$()));
+ return MappedIterableOfString$dynamic().new(this[_computeKeys$](), dart.fn(each => this._get(each), dynamicTodynamic$()));
}
- set(key, value) {
+ _set(key, value) {
if (dart.test(this[_isUpgraded])) {
- this[_upgradedMap][dartx.set](key, value);
+ this[_upgradedMap][dartx._set](key, value);
} else if (dart.test(this.containsKey(key))) {
let processed = this[_processed];
convert._JsonMap._setProperty(processed, core.String._check(key), value);
@@ -28526,21 +28525,21 @@
convert._JsonMap._setProperty(original, core.String._check(key), null);
}
} else {
- this[_upgrade]()[dartx.set](key, value);
+ this[_upgrade]()[dartx._set](key, value);
}
return value;
}
addAll(other) {
other[dartx.forEach](dart.fn((key, value) => {
- this.set(key, value);
+ this._set(key, value);
}, dynamicAnddynamicTovoid$()));
}
containsValue(value) {
if (dart.test(this[_isUpgraded])) return this[_upgradedMap][dartx.containsValue](value);
let keys = this[_computeKeys$]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
- if (dart.equals(this.get(key), value)) return true;
+ let key = keys[dartx._get](i);
+ if (dart.equals(this._get(key), value)) return true;
}
return false;
}
@@ -28550,9 +28549,9 @@
return convert._JsonMap._hasProperty(this[_original], core.String._check(key));
}
putIfAbsent(key, ifAbsent) {
- if (dart.test(this.containsKey(key))) return this.get(key);
+ if (dart.test(this.containsKey(key))) return this._get(key);
let value = ifAbsent();
- this.set(key, value);
+ this._set(key, value);
return value;
}
remove(key) {
@@ -28574,7 +28573,7 @@
if (dart.test(this[_isUpgraded])) return this[_upgradedMap][dartx.forEach](f);
let keys = this[_computeKeys$]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
+ let key = keys[dartx._get](i);
let value = convert._JsonMap._getProperty(this[_processed], key);
if (dart.test(convert._JsonMap._isUnprocessed(value))) {
value = convert._convertJsonToDartLazy(convert._JsonMap._getProperty(this[_original], key));
@@ -28609,8 +28608,8 @@
let result = dart.map();
let keys = this[_computeKeys$]();
for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
- let key = keys[dartx.get](i);
- result[dartx.set](key, this.get(key));
+ let key = keys[dartx._get](i);
+ result[dartx._set](key, this._get(key));
}
if (dart.test(keys[dartx.isEmpty])) {
keys[dartx.add](null);
@@ -28664,8 +28663,8 @@
[_upgradedMap]: dart.definiteFunctionType(core.Map, [])
}),
methods: () => ({
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [dart.dynamic, dart.dynamic]),
addAll: dart.definiteFunctionType(dart.void, [core.Map]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
@@ -28688,8 +28687,8 @@
names: ['_hasProperty', '_getProperty', '_setProperty', '_getPropertyNames', '_isUnprocessed', '_newJavaScriptObject']
});
dart.defineExtensionMembers(convert._JsonMap, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'addAll',
'containsValue',
'containsKey',
@@ -28713,7 +28712,7 @@
return this[_parent].length;
}
elementAt(index) {
- return core.String._check(dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.elementAt](index) : this[_parent][_computeKeys$]()[dartx.get](index));
+ return core.String._check(dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.elementAt](index) : this[_parent][_computeKeys$]()[dartx._get](index));
}
get iterator() {
return dart.test(this[_parent][_isUpgraded]) ? this[_parent].keys[dartx.iterator] : this[_parent][_computeKeys$]()[dartx.iterator];
@@ -28957,7 +28956,7 @@
let result = ListOfE().new(length);
if (length != 0 && fill != null) {
for (let i = 0; i < dart.notNull(result[dartx.length]); i++) {
- result[dartx.set](i, fill);
+ result[dartx._set](i, fill);
}
}
return result;
@@ -28981,7 +28980,7 @@
result = ListOfE().new(length);
}
for (let i = 0; i < dart.notNull(length); i++) {
- result[dartx.set](i, generator(i));
+ result[dartx._set](i, generator(i));
}
return result;
}
@@ -29020,7 +29019,7 @@
static getByName(name) {
if (name == null) return null;
name = name[dartx.toLowerCase]();
- return convert.Encoding._nameToEncoding[dartx.get](name);
+ return convert.Encoding._nameToEncoding[dartx._get](name);
}
};
dart.addSimpleTypeTests(convert.Encoding);
@@ -29131,7 +29130,7 @@
if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) != 0) {
dart.throw(new core.ArgumentError("String contains invalid characters."));
}
- result[dartx.set](i, codeUnit);
+ result[dartx._set](i, codeUnit);
}
return result;
}
@@ -29210,7 +29209,7 @@
core.RangeError.checkValidRange(start, end, byteCount);
if (end == null) end = byteCount;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
if ((dart.notNull(byte) & ~dart.notNull(this[_subsetMask])) != 0) {
if (!dart.test(this[_allowInvalid])) {
dart.throw(new core.FormatException(dart.str`Invalid value in input: ${byte}`));
@@ -29223,7 +29222,7 @@
[_convertInvalid](bytes, start, end) {
let buffer = new core.StringBuffer();
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let value = bytes[dartx.get](i);
+ let value = bytes[dartx._get](i);
if ((dart.notNull(value) & ~dart.notNull(this[_subsetMask])) != 0) value = 65533;
buffer.writeCharCode(value);
}
@@ -29339,7 +29338,7 @@
addSlice(source, start, end, isLast) {
core.RangeError.checkValidRange(start, end, source[dartx.length]);
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- if ((dart.notNull(source[dartx.get](i)) & ~convert._ASCII_MASK) != 0) {
+ if ((dart.notNull(source[dartx._get](i)) & ~convert._ASCII_MASK) != 0) {
if (dart.notNull(i) > dart.notNull(start)) this[_utf8Sink].addSlice(source, start, i, false);
this[_utf8Sink].add(const$30 || (const$30 = dart.constList([239, 191, 189], core.int)));
start = dart.notNull(i) + 1;
@@ -29370,7 +29369,7 @@
}
add(source) {
for (let i = 0; i < dart.notNull(source[dartx.length]); i++) {
- if ((dart.notNull(source[dartx.get](i)) & ~convert._ASCII_MASK) != 0) {
+ if ((dart.notNull(source[dartx._get](i)) & ~convert._ASCII_MASK) != 0) {
dart.throw(new core.FormatException("Source contains non-ASCII bytes."));
}
}
@@ -29511,27 +29510,27 @@
let expectedChars = 3 - dart.notNull(convert._Base64Encoder._stateCount(state));
let byteOr = 0;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
byteOr = (dart.notNull(byteOr) | dart.notNull(byte)) >>> 0;
bits = (dart.notNull(bits) << 8 | dart.notNull(byte)) & 16777215;
expectedChars--;
if (expectedChars == 0) {
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 18 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 12 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 6 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
@@ -29549,53 +29548,53 @@
}
let i = start;
while (dart.notNull(i) < dart.notNull(end)) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) break;
i = dart.notNull(i) + 1;
}
- dart.throw(new core.ArgumentError.value(bytes, dart.str`Not a byte value at index ${i}: 0x${bytes[dartx.get](i)[dartx.toRadixString](16)}`));
+ dart.throw(new core.ArgumentError.value(bytes, dart.str`Not a byte value at index ${i}: 0x${bytes[dartx._get](i)[dartx.toRadixString](16)}`));
}
static writeFinalChunk(alphabet, output, outputIndex, count, bits) {
dart.assert(dart.notNull(count) > 0);
if (count == 1) {
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 2 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) << 4 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), convert._paddingChar);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), convert._paddingChar);
} else {
dart.assert(count == 2);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 10 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) >> 4 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
})(), alphabet[dartx.codeUnitAt](dart.notNull(bits) << 2 & convert._Base64Encoder._sixBitMask));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outputIndex;
outputIndex = dart.notNull(x) + 1;
return x;
@@ -29807,23 +29806,23 @@
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
let char = input[dartx.codeUnitAt](i);
charOr = (dart.notNull(charOr) | dart.notNull(char)) >>> 0;
- let code = convert._Base64Decoder._inverseAlphabet[dartx.get]((dart.notNull(char) & asciiMask) >>> 0);
+ let code = convert._Base64Decoder._inverseAlphabet[dartx._get]((dart.notNull(char) & asciiMask) >>> 0);
if (dart.notNull(code) >= 0) {
bits = (bits[dartx['<<']](bitsPerCharacter) | dart.notNull(code)) & 16777215;
count = dart.notNull(count) + 1 & 3;
if (count == 0) {
dart.assert(dart.notNull(outIndex) + 3 <= dart.notNull(output[dartx.length]));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
})(), (bits[dartx['>>']](16) & eightBitMask) >>> 0);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
})(), (bits[dartx['>>']](8) & eightBitMask) >>> 0);
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
@@ -29837,12 +29836,12 @@
if ((dart.notNull(bits) & 3) != 0) {
dart.throw(new core.FormatException("Invalid encoding before padding", input, i));
}
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
})(), bits[dartx['>>']](10));
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
@@ -29851,7 +29850,7 @@
if ((dart.notNull(bits) & 15) != 0) {
dart.throw(new core.FormatException("Invalid encoding before padding", input, i));
}
- output[dartx.set]((() => {
+ output[dartx._set]((() => {
let x = outIndex;
outIndex = dart.notNull(x) + 1;
return x;
@@ -30403,7 +30402,7 @@
[_convert](text, start, end) {
let result = null;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let ch = text[dartx.get](i);
+ let ch = text[dartx._get](i);
let replacement = null;
switch (ch) {
case '&':
@@ -30675,14 +30674,14 @@
}
dart.fn(addChunk, Uint8ListAndintAndintTovoid$());
convert._JsonUtf8Stringifier.stringify(object, this[_indent], this[_toEncodable], this[_bufferSize], addChunk);
- if (bytes[dartx.length] == 1) return bytes[dartx.get](0);
+ if (bytes[dartx.length] == 1) return bytes[dartx._get](0);
let length = 0;
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- length = dart.notNull(length) + dart.notNull(bytes[dartx.get](i)[dartx.length]);
+ length = dart.notNull(length) + dart.notNull(bytes[dartx._get](i)[dartx.length]);
}
let result = typed_data.Uint8List.new(length);
for (let i = 0, offset = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byteList = bytes[dartx.get](i);
+ let byteList = bytes[dartx._get](i);
let end = offset + dart.notNull(byteList[dartx.length]);
result[dartx.setRange](offset, end, byteList);
offset = end;
@@ -30919,7 +30918,7 @@
}
[_checkCycle](object) {
for (let i = 0; i < dart.notNull(this[_seen][dartx.length]); i++) {
- if (core.identical(object, this[_seen][dartx.get](i))) {
+ if (core.identical(object, this[_seen][dartx._get](i))) {
dart.throw(new convert.JsonCyclicError(object));
}
}
@@ -30980,10 +30979,10 @@
writeList(list) {
this.writeString('[');
if (dart.notNull(list[dartx.length]) > 0) {
- this.writeObject(list[dartx.get](0));
+ this.writeObject(list[dartx._get](0));
for (let i = 1; i < dart.notNull(list[dartx.length]); i++) {
this.writeString(',');
- this.writeObject(list[dartx.get](i));
+ this.writeObject(list[dartx._get](i));
}
}
this.writeString(']');
@@ -31000,8 +30999,8 @@
if (!(typeof key == 'string')) {
allStringKeys = false;
}
- keyValueList[dartx.set](i++, key);
- keyValueList[dartx.set](i++, value);
+ keyValueList[dartx._set](i++, key);
+ keyValueList[dartx._set](i++, value);
}, dynamicAnddynamicTovoid$()));
if (!allStringKeys) return false;
this.writeString('{');
@@ -31009,9 +31008,9 @@
for (let i = 0; i < dart.notNull(keyValueList[dartx.length]); i = i + 2) {
this.writeString(separator);
separator = ',"';
- this.writeStringContent(core.String._check(keyValueList[dartx.get](i)));
+ this.writeStringContent(core.String._check(keyValueList[dartx._get](i)));
this.writeString('":');
- this.writeObject(keyValueList[dartx.get](i + 1));
+ this.writeObject(keyValueList[dartx._get](i + 1));
}
this.writeString('}');
return true;
@@ -31077,11 +31076,11 @@
this.writeString('[\n');
this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
this.writeIndentation(this[_indentLevel]);
- this.writeObject(list[dartx.get](0));
+ this.writeObject(list[dartx._get](0));
for (let i = 1; i < dart.notNull(list[dartx.length]); i++) {
this.writeString(',\n');
this.writeIndentation(this[_indentLevel]);
- this.writeObject(list[dartx.get](i));
+ this.writeObject(list[dartx._get](i));
}
this.writeString('\n');
this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
@@ -31101,8 +31100,8 @@
if (!(typeof key == 'string')) {
allStringKeys = false;
}
- keyValueList[dartx.set](i++, key);
- keyValueList[dartx.set](i++, value);
+ keyValueList[dartx._set](i++, key);
+ keyValueList[dartx._set](i++, value);
}, dynamicAnddynamicTovoid$()));
if (!allStringKeys) return false;
this.writeString('{\n');
@@ -31113,9 +31112,9 @@
separator = ",\n";
this.writeIndentation(this[_indentLevel]);
this.writeString('"');
- this.writeStringContent(core.String._check(keyValueList[dartx.get](i)));
+ this.writeStringContent(core.String._check(keyValueList[dartx._get](i)));
this.writeString('": ');
- this.writeObject(keyValueList[dartx.get](i + 1));
+ this.writeObject(keyValueList[dartx._get](i + 1));
}
this.writeString('\n');
this[_indentLevel] = dart.notNull(this[_indentLevel]) - 1;
@@ -31287,7 +31286,7 @@
this.buffer = typed_data.Uint8List.new(this.bufferSize);
this.index = 0;
}
- this.buffer[dartx.set]((() => {
+ this.buffer[dartx._set]((() => {
let x = this.index;
this.index = dart.notNull(x) + 1;
return x;
@@ -31325,7 +31324,7 @@
let indent = this.indent;
let indentLength = indent[dartx.length];
if (indentLength == 1) {
- let char = indent[dartx.get](0);
+ let char = indent[dartx._get](0);
while (dart.notNull(count) > 0) {
this.writeByte(char);
count = dart.notNull(count) - 1;
@@ -31340,7 +31339,7 @@
this.index = end;
} else {
for (let i = 0; i < dart.notNull(indentLength); i++) {
- this.writeByte(indent[dartx.get](i));
+ this.writeByte(indent[dartx._get](i));
}
}
}
@@ -31449,7 +31448,7 @@
static _checkValidLatin1(source, start, end) {
let mask = 0;
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- mask = (dart.notNull(mask) | dart.notNull(source[dartx.get](i))) >>> 0;
+ mask = (dart.notNull(mask) | dart.notNull(source[dartx._get](i))) >>> 0;
}
if (dart.notNull(mask) >= 0 && dart.notNull(mask) <= convert._LATIN1_MASK) {
return;
@@ -31458,7 +31457,7 @@
}
static _reportInvalidLatin1(source, start, end) {
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let char = source[dartx.get](i);
+ let char = source[dartx._get](i);
if (dart.notNull(char) < 0 || dart.notNull(char) > convert._LATIN1_MASK) {
dart.throw(new core.FormatException("Source contains non-Latin-1 characters.", source, i));
}
@@ -31488,7 +31487,7 @@
addSlice(source, start, end, isLast) {
core.RangeError.checkValidRange(start, end, source[dartx.length]);
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- let char = source[dartx.get](i);
+ let char = source[dartx._get](i);
if (dart.notNull(char) > convert._LATIN1_MASK || dart.notNull(char) < 0) {
if (dart.notNull(i) > dart.notNull(start)) this[_addSliceToSink](source, start, i, false);
this[_addSliceToSink](const$49 || (const$49 = dart.constList([65533], core.int)), 0, 1, false);
@@ -32028,39 +32027,39 @@
let rune = convert._combineSurrogatePair(leadingSurrogate, nextCodeUnit);
dart.assert(dart.notNull(rune) > convert._THREE_BYTE_LIMIT);
dart.assert(dart.notNull(rune) <= convert._FOUR_BYTE_LIMIT);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (240 | rune[dartx['>>']](18)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) >> 12 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) >> 6 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) & 63);
return true;
} else {
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (224 | leadingSurrogate[dartx['>>']](12)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(leadingSurrogate) >> 6 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32077,7 +32076,7 @@
let codeUnit = str[dartx.codeUnitAt](stringIndex);
if (dart.notNull(codeUnit) <= convert._ONE_BYTE_LIMIT) {
if (dart.notNull(this[_bufferIndex]) >= dart.notNull(this[_buffer][dartx.length])) break;
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32093,12 +32092,12 @@
let rune = codeUnit;
if (dart.notNull(rune) <= convert._TWO_BYTE_LIMIT) {
if (dart.notNull(this[_bufferIndex]) + 1 >= dart.notNull(this[_buffer][dartx.length])) break;
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (192 | rune[dartx['>>']](6)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32106,17 +32105,17 @@
} else {
dart.assert(dart.notNull(rune) <= convert._THREE_BYTE_LIMIT);
if (dart.notNull(this[_bufferIndex]) + 2 >= dart.notNull(this[_buffer][dartx.length])) break;
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), (224 | rune[dartx['>>']](12)) >>> 0);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
})(), 128 | dart.notNull(rune) >> 6 & 63);
- this[_buffer][dartx.set]((() => {
+ this[_buffer][dartx._set]((() => {
let x = this[_bufferIndex];
this[_bufferIndex] = dart.notNull(x) + 1;
return x;
@@ -32343,7 +32342,7 @@
if (i == endIndex) {
break loop;
}
- let unit = codeUnits[dartx.get](i);
+ let unit = codeUnits[dartx._get](i);
if ((dart.notNull(unit) & 192) != 128) {
expectedUnits = 0;
if (!dart.test(this[_allowMalformed])) {
@@ -32358,7 +32357,7 @@
i = dart.notNull(i) + 1;
}
} while (dart.notNull(expectedUnits) > 0);
- if (dart.notNull(value) <= dart.notNull(convert._Utf8Decoder._LIMITS[dartx.get](dart.notNull(extraUnits) - 1))) {
+ if (dart.notNull(value) <= dart.notNull(convert._Utf8Decoder._LIMITS[dartx._get](dart.notNull(extraUnits) - 1))) {
if (!dart.test(this[_allowMalformed])) {
dart.throw(new core.FormatException(dart.str`Overlong encoding of 0x${value[dartx.toRadixString](16)}`));
}
@@ -32384,7 +32383,7 @@
i = dart.notNull(i) + dart.notNull(oneBytes);
if (i == endIndex) break;
}
- let unit = codeUnits[dartx.get]((() => {
+ let unit = codeUnits[dartx._get]((() => {
let x = i;
i = dart.notNull(x) + 1;
return x;
@@ -32580,23 +32579,23 @@
return result;
}
dart.fn(parseMilliAndMicroseconds, StringToint$());
- let years = core.int.parse(match.get(1));
- let month = core.int.parse(match.get(2));
- let day = core.int.parse(match.get(3));
- let hour = parseIntOrZero(match.get(4));
- let minute = parseIntOrZero(match.get(5));
- let second = parseIntOrZero(match.get(6));
+ let years = core.int.parse(match._get(1));
+ let month = core.int.parse(match._get(2));
+ let day = core.int.parse(match._get(3));
+ let hour = parseIntOrZero(match._get(4));
+ let minute = parseIntOrZero(match._get(5));
+ let second = parseIntOrZero(match._get(6));
let addOneMillisecond = false;
- let milliAndMicroseconds = parseMilliAndMicroseconds(match.get(7));
+ let milliAndMicroseconds = parseMilliAndMicroseconds(match._get(7));
let millisecond = (dart.notNull(milliAndMicroseconds) / core.Duration.MICROSECONDS_PER_MILLISECOND)[dartx.truncate]();
let microsecond = dart.asInt(milliAndMicroseconds[dartx.remainder](core.Duration.MICROSECONDS_PER_MILLISECOND));
let isUtc = false;
- if (match.get(8) != null) {
+ if (match._get(8) != null) {
isUtc = true;
- if (match.get(9) != null) {
- let sign = match.get(9) == '-' ? -1 : 1;
- let hourDifference = core.int.parse(match.get(10));
- let minuteDifference = parseIntOrZero(match.get(11));
+ if (match._get(9) != null) {
+ let sign = match._get(9) == '-' ? -1 : 1;
+ let hourDifference = core.int.parse(match._get(10));
+ let minuteDifference = parseIntOrZero(match._get(11));
minuteDifference = dart.notNull(minuteDifference) + 60 * dart.notNull(hourDifference);
minute = dart.notNull(minute) - sign * dart.notNull(minuteDifference);
}
@@ -32966,7 +32965,7 @@
}
dart.fn(twoDigits, intToString());
if (dart.notNull(this.inMicroseconds) < 0) {
- return dart.str`-${this['unary-']()}`;
+ return dart.str`-${this._negate()}`;
}
let twoDigitMinutes = twoDigits(dart.asInt(this.inMinutes[dartx.remainder](core.Duration.MINUTES_PER_HOUR)));
let twoDigitSeconds = twoDigits(dart.asInt(this.inSeconds[dartx.remainder](core.Duration.SECONDS_PER_MINUTE)));
@@ -32979,7 +32978,7 @@
abs() {
return new core.Duration._microseconds(this[_duration][dartx.abs]());
}
- ['unary-']() {
+ _negate() {
return new core.Duration._microseconds(-dart.notNull(this[_duration]));
}
};
@@ -33011,7 +33010,7 @@
'>=': dart.definiteFunctionType(core.bool, [core.Duration]),
compareTo: dart.definiteFunctionType(core.int, [core.Duration]),
abs: dart.definiteFunctionType(core.Duration, []),
- 'unary-': dart.definiteFunctionType(core.Duration, [])
+ _negate: dart.definiteFunctionType(core.Duration, [])
}),
sfields: () => ({
MICROSECONDS_PER_MILLISECOND: core.int,
@@ -33341,7 +33340,7 @@
if (i > 0) {
sb.write(", ");
}
- sb.write(core.Error.safeToString(this[_arguments][dartx.get](i)));
+ sb.write(core.Error.safeToString(this[_arguments][dartx._get](i)));
}
}
if (this[_namedArguments] != null) {
@@ -33364,7 +33363,7 @@
if (i > 0) {
sb.write(", ");
}
- sb.write(this[_existingArgumentNames][dartx.get](i));
+ sb.write(this[_existingArgumentNames][dartx._get](i));
}
let formalParameters = sb.toString();
return "NoSuchMethodError: incorrect number of arguments passed to " + dart.str`method named '${this[_memberName]}'\n` + dart.str`Receiver: ${core.Error.safeToString(this[_receiver$])}\n` + dart.str`Tried calling: ${this[_memberName]}(${actualParameters})\n` + dart.str`Found: ${this[_memberName]}(${formalParameters})`;
@@ -33622,11 +33621,11 @@
toString() {
return dart.str`Expando:${this.name}`;
}
- get(object) {
+ _get(object) {
let values = _js_helper.Primitives.getProperty(object, core.Expando._EXPANDO_PROPERTY_NAME);
return T._check(values == null ? null : _js_helper.Primitives.getProperty(values, this[_getKey]()));
}
- set(object, value) {
+ _set(object, value) {
T._check(value);
let values = _js_helper.Primitives.getProperty(object, core.Expando._EXPANDO_PROPERTY_NAME);
if (values == null) {
@@ -33654,8 +33653,8 @@
constructors: () => ({new: dart.definiteFunctionType(core.Expando$(T), [], [core.String])}),
fields: () => ({name: core.String}),
methods: () => ({
- get: dart.definiteFunctionType(T, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.Object, T]),
+ _get: dart.definiteFunctionType(T, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.Object, T]),
[_getKey]: dart.definiteFunctionType(core.String, [])
}),
sfields: () => ({
@@ -33678,7 +33677,7 @@
static _toMangledNames(namedArguments) {
let result = dart.map({}, core.String, dart.dynamic);
namedArguments[dartx.forEach](dart.fn((symbol, value) => {
- result[dartx.set](core._symbolToString(symbol), value);
+ result[dartx._set](core._symbolToString(symbol), value);
}, SymbolAnddynamicTovoid()));
return result;
}
@@ -34156,7 +34155,7 @@
}
get currentAsString() {
if (this[_position$] == this[_nextPosition]) return null;
- if (dart.notNull(this[_position$]) + 1 == this[_nextPosition]) return this.string[dartx.get](this[_position$]);
+ if (dart.notNull(this[_position$]) + 1 == this[_nextPosition]) return this.string[dartx._get](this[_position$]);
return this.string[dartx.substring](this[_position$], this[_nextPosition]);
}
moveNext() {
@@ -34844,7 +34843,7 @@
if (this[_queryParameterLists] == null) {
let queryParameterLists = core.Uri._splitQueryStringAll(this.query);
for (let key of queryParameterLists[dartx.keys]) {
- queryParameterLists[dartx.set](key, ListOfString().unmodifiable(core.Iterable._check(queryParameterLists[dartx.get](key))));
+ queryParameterLists[dartx._set](key, ListOfString().unmodifiable(core.Iterable._check(queryParameterLists[dartx._get](key))));
}
this[_queryParameterLists] = MapOfString$ListOfString().unmodifiable(queryParameterLists);
}
@@ -34880,7 +34879,7 @@
return core.Uri._normalizeRegName(host, start, end);
}
static _isRegNameChar(char) {
- return dart.notNull(char) < 127 && (dart.notNull(core.Uri._regNameTable[dartx.get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
+ return dart.notNull(char) < 127 && (dart.notNull(core.Uri._regNameTable[dartx._get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
}
static _normalizeRegName(host, start, end) {
let buffer = null;
@@ -35075,9 +35074,9 @@
let codeUnits = null;
if (dart.notNull(char) < 128) {
codeUnits = ListOfint().new(3);
- codeUnits[dartx.set](0, core.Uri._PERCENT);
- codeUnits[dartx.set](1, core.Uri._hexDigits[dartx.codeUnitAt](char[dartx['>>']](4)));
- codeUnits[dartx.set](2, core.Uri._hexDigits[dartx.codeUnitAt](dart.notNull(char) & 15));
+ codeUnits[dartx._set](0, core.Uri._PERCENT);
+ codeUnits[dartx._set](1, core.Uri._hexDigits[dartx.codeUnitAt](char[dartx['>>']](4)));
+ codeUnits[dartx._set](2, core.Uri._hexDigits[dartx.codeUnitAt](dart.notNull(char) & 15));
} else {
let flag = 192;
let encodedBytes = 2;
@@ -35093,9 +35092,9 @@
let index = 0;
while (--encodedBytes >= 0) {
let byte = (char[dartx['>>']](6 * encodedBytes) & 63 | flag) >>> 0;
- codeUnits[dartx.set](index, core.Uri._PERCENT);
- codeUnits[dartx.set](index + 1, core.Uri._hexDigits[dartx.codeUnitAt](byte[dartx['>>']](4)));
- codeUnits[dartx.set](index + 2, core.Uri._hexDigits[dartx.codeUnitAt](byte & 15));
+ codeUnits[dartx._set](index, core.Uri._PERCENT);
+ codeUnits[dartx._set](index + 1, core.Uri._hexDigits[dartx.codeUnitAt](byte[dartx['>>']](4)));
+ codeUnits[dartx._set](index + 2, core.Uri._hexDigits[dartx.codeUnitAt](byte & 15));
index = index + 3;
flag = 128;
}
@@ -35108,7 +35107,7 @@
let index = start;
while (dart.notNull(index) < dart.notNull(end)) {
let char = component[dartx.codeUnitAt](index);
- if (dart.notNull(char) < 127 && (dart.notNull(charTable[dartx.get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0) {
+ if (dart.notNull(char) < 127 && (dart.notNull(charTable[dartx._get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0) {
index = dart.notNull(index) + 1;
} else {
let replacement = null;
@@ -35156,10 +35155,10 @@
return dart.toString(buffer);
}
static _isSchemeCharacter(ch) {
- return dart.notNull(ch) < 128 && (dart.notNull(core.Uri._schemeTable[dartx.get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
+ return dart.notNull(ch) < 128 && (dart.notNull(core.Uri._schemeTable[dartx._get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
}
static _isGeneralDelimiter(ch) {
- return dart.notNull(ch) <= core.Uri._RIGHT_BRACKET && (dart.notNull(core.Uri._genDelimitersTable[dartx.get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
+ return dart.notNull(ch) <= core.Uri._RIGHT_BRACKET && (dart.notNull(core.Uri._genDelimitersTable[dartx._get](ch[dartx['>>']](4))) & 1 << (dart.notNull(ch) & 15)) != 0;
}
get isAbsolute() {
return this.scheme != "" && this.fragment == "";
@@ -35236,7 +35235,7 @@
output[dartx.add](segment);
}
}
- if (dart.test(output[dartx.isEmpty]) || output[dartx.length] == 1 && dart.test(output[dartx.get](0)[dartx.isEmpty])) {
+ if (dart.test(output[dartx.isEmpty]) || output[dartx.length] == 1 && dart.test(output[dartx._get](0)[dartx.isEmpty])) {
return "./";
}
if (appendSlash || output[dartx.last] == '..') output[dartx.add]("");
@@ -35366,8 +35365,8 @@
[_toWindowsFilePath]() {
let hasDriveLetter = false;
let segments = this.pathSegments;
- if (dart.notNull(segments[dartx.length]) > 0 && segments[dartx.get](0)[dartx.length] == 2 && segments[dartx.get](0)[dartx.codeUnitAt](1) == core.Uri._COLON) {
- core.Uri._checkWindowsDriveLetter(segments[dartx.get](0)[dartx.codeUnitAt](0), false);
+ if (dart.notNull(segments[dartx.length]) > 0 && segments[dartx._get](0)[dartx.length] == 2 && segments[dartx._get](0)[dartx.codeUnitAt](1) == core.Uri._COLON) {
+ core.Uri._checkWindowsDriveLetter(segments[dartx._get](0)[dartx.codeUnitAt](0), false);
core.Uri._checkWindowsPathReservedCharacters(segments, false, 1);
hasDriveLetter = true;
} else {
@@ -35464,12 +35463,12 @@
let index = element[dartx.indexOf]("=");
if (index == -1) {
if (element != "") {
- map[dartx.set](core.Uri.decodeQueryComponent(element, {encoding: encoding}), "");
+ map[dartx._set](core.Uri.decodeQueryComponent(element, {encoding: encoding}), "");
}
} else if (index != 0) {
let key = element[dartx.substring](0, index);
let value = element[dartx.substring](dart.notNull(index) + 1);
- map[dartx.set](core.Uri.decodeQueryComponent(key, {encoding: encoding}), core.Uri.decodeQueryComponent(value, {encoding: encoding}));
+ map[dartx._set](core.Uri.decodeQueryComponent(key, {encoding: encoding}), core.Uri.decodeQueryComponent(value, {encoding: encoding}));
}
return map;
}, MapOfString$StringAndStringToMapOfString$String()));
@@ -35587,8 +35586,8 @@
} catch (e) {
try {
let last = core.Uri.parseIPv4Address(host[dartx.substring](partStart, end));
- parts[dartx.add]((dart.notNull(last[dartx.get](0)) << 8 | dart.notNull(last[dartx.get](1))) >>> 0);
- parts[dartx.add]((dart.notNull(last[dartx.get](2)) << 8 | dart.notNull(last[dartx.get](3))) >>> 0);
+ parts[dartx.add]((dart.notNull(last[dartx._get](0)) << 8 | dart.notNull(last[dartx._get](1))) >>> 0);
+ parts[dartx.add]((dart.notNull(last[dartx._get](2)) << 8 | dart.notNull(last[dartx._get](3))) >>> 0);
} catch (e) {
error('invalid end of IPv6 address.', partStart);
}
@@ -35605,17 +35604,17 @@
}
let bytes = typed_data.Uint8List.new(16);
for (let i = 0, index = 0; i < dart.notNull(parts[dartx.length]); i++) {
- let value = parts[dartx.get](i);
+ let value = parts[dartx._get](i);
if (value == -1) {
let wildCardLength = 9 - dart.notNull(parts[dartx.length]);
for (let j = 0; j < wildCardLength; j++) {
- bytes[dartx.set](index, 0);
- bytes[dartx.set](index + 1, 0);
+ bytes[dartx._set](index, 0);
+ bytes[dartx._set](index + 1, 0);
index = index + 2;
}
} else {
- bytes[dartx.set](index, value[dartx['>>']](8));
- bytes[dartx.set](index + 1, dart.notNull(value) & 255);
+ bytes[dartx._set](index, value[dartx['>>']](8));
+ bytes[dartx._set](index + 1, dart.notNull(value) & 255);
index = index + 2;
}
}
@@ -35628,16 +35627,16 @@
let result = new core.StringBuffer();
let bytes = encoding.encode(text);
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byte = bytes[dartx.get](i);
- if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx.get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
+ let byte = bytes[dartx._get](i);
+ if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx._get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
result.writeCharCode(byte);
} else if (dart.test(spaceToPlus) && byte == core.Uri._SPACE) {
result.write('+');
} else {
let hexDigits = '0123456789ABCDEF';
result.write('%');
- result.write(hexDigits[dartx.get](dart.notNull(byte) >> 4 & 15));
- result.write(hexDigits[dartx.get](dart.notNull(byte) & 15));
+ result.write(hexDigits[dartx._get](dart.notNull(byte) >> 4 & 15));
+ result.write(hexDigits[dartx._get](dart.notNull(byte) & 15));
}
}
return result.toString();
@@ -35706,7 +35705,7 @@
return core.Uri._LOWER_CASE_A <= lowerCase && lowerCase <= core.Uri._LOWER_CASE_Z;
}
static _isUnreservedChar(char) {
- return dart.notNull(char) < 127 && (dart.notNull(core.Uri._unreservedTable[dartx.get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
+ return dart.notNull(char) < 127 && (dart.notNull(core.Uri._unreservedTable[dartx._get](char[dartx['>>']](4))) & 1 << (dart.notNull(char) & 15)) != 0;
}
};
dart.defineNamedConstructor(core.Uri, '_internal');
@@ -35924,7 +35923,7 @@
let indices = JSArrayOfint().of([core.UriData._noScheme]);
let charsetName = null;
let encodingName = null;
- if (parameters != null) charsetName = parameters[dartx.get]("charset");
+ if (parameters != null) charsetName = parameters[dartx._get]("charset");
if (encoding == null) {
if (charsetName != null) {
encoding = convert.Encoding.getByName(charsetName);
@@ -36040,7 +36039,7 @@
if (this[_uriCache] != null) return this[_uriCache];
let path = this[_text];
let query = null;
- let colonIndex = this[_separatorIndices][dartx.get](0);
+ let colonIndex = this[_separatorIndices][dartx._get](0);
let queryIndex = this[_text][dartx.indexOf]('?', dart.notNull(colonIndex) + 1);
let end = null;
if (dart.notNull(queryIndex) >= 0) {
@@ -36052,8 +36051,8 @@
return this[_uriCache];
}
get mimeType() {
- let start = dart.notNull(this[_separatorIndices][dartx.get](0)) + 1;
- let end = this[_separatorIndices][dartx.get](1);
+ let start = dart.notNull(this[_separatorIndices][dartx._get](0)) + 1;
+ let end = this[_separatorIndices][dartx._get](1);
if (start == end) return "text/plain";
return core.Uri._uriDecode(this[_text], start, end, convert.UTF8, false);
}
@@ -36064,10 +36063,10 @@
parameterEnd = parameterEnd - 1;
}
for (let i = parameterStart; i < parameterEnd; i = i + 2) {
- let keyStart = dart.notNull(this[_separatorIndices][dartx.get](i)) + 1;
- let keyEnd = this[_separatorIndices][dartx.get](i + 1);
+ let keyStart = dart.notNull(this[_separatorIndices][dartx._get](i)) + 1;
+ let keyEnd = this[_separatorIndices][dartx._get](i + 1);
if (keyEnd == keyStart + 7 && dart.test(this[_text][dartx.startsWith]("charset", keyStart))) {
- return core.Uri._uriDecode(this[_text], dart.notNull(keyEnd) + 1, this[_separatorIndices][dartx.get](i + 2), convert.UTF8, false);
+ return core.Uri._uriDecode(this[_text], dart.notNull(keyEnd) + 1, this[_separatorIndices][dartx._get](i + 2), convert.UTF8, false);
}
}
return "US-ASCII";
@@ -36102,14 +36101,14 @@
for (let i = start; i < dart.notNull(text[dartx.length]); i++) {
let codeUnit = text[dartx.codeUnitAt](i);
if (codeUnit != percent) {
- result[dartx.set](index++, codeUnit);
+ result[dartx._set](index++, codeUnit);
} else {
if (i + 2 < dart.notNull(text[dartx.length])) {
let digit1 = core.Uri._parseHexDigit(text[dartx.codeUnitAt](i + 1));
let digit2 = core.Uri._parseHexDigit(text[dartx.codeUnitAt](i + 2));
if (dart.notNull(digit1) >= 0 && dart.notNull(digit2) >= 0) {
let byte = dart.notNull(digit1) * 16 + dart.notNull(digit2);
- result[dartx.set](index++, byte);
+ result[dartx._set](index++, byte);
i = i + 2;
continue;
}
@@ -36140,12 +36139,12 @@
get parameters() {
let result = dart.map({}, core.String, core.String);
for (let i = 3; i < dart.notNull(this[_separatorIndices][dartx.length]); i = i + 2) {
- let start = dart.notNull(this[_separatorIndices][dartx.get](i - 2)) + 1;
- let equals = this[_separatorIndices][dartx.get](i - 1);
- let end = this[_separatorIndices][dartx.get](i);
+ let start = dart.notNull(this[_separatorIndices][dartx._get](i - 2)) + 1;
+ let equals = this[_separatorIndices][dartx._get](i - 1);
+ let end = this[_separatorIndices][dartx._get](i);
let key = core.Uri._uriDecode(this[_text], start, equals, convert.UTF8, false);
let value = core.Uri._uriDecode(this[_text], dart.notNull(equals) + 1, end, convert.UTF8, false);
- result[dartx.set](key, value);
+ result[dartx._set](key, value);
}
return result;
}
@@ -36202,9 +36201,9 @@
static _uriEncodeBytes(canonicalTable, bytes, buffer) {
let byteOr = 0;
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
byteOr = (dart.notNull(byteOr) | dart.notNull(byte)) >>> 0;
- if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx.get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
+ if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx._get](byte[dartx['>>']](4))) & 1 << (dart.notNull(byte) & 15)) != 0) {
buffer.writeCharCode(byte);
} else {
buffer.writeCharCode(core.Uri._PERCENT);
@@ -36214,7 +36213,7 @@
}
if ((dart.notNull(byteOr) & ~255) != 0) {
for (let i = 0; i < dart.notNull(bytes[dartx.length]); i++) {
- let byte = bytes[dartx.get](i);
+ let byte = bytes[dartx._get](i);
if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) {
dart.throw(new core.ArgumentError.value(byte, "non-byte value"));
}
@@ -36222,7 +36221,7 @@
}
}
toString() {
- return this[_separatorIndices][dartx.get](0) == core.UriData._noScheme ? dart.str`data:${this[_text]}` : this[_text];
+ return this[_separatorIndices][dartx._get](0) == core.UriData._noScheme ? dart.str`data:${this[_text]}` : this[_text];
}
};
dart.defineNamedConstructor(core.UriData, '_');
@@ -36295,7 +36294,7 @@
static spawn(entryPoint, message, opts) {
let paused = opts && 'paused' in opts ? opts.paused : false;
try {
- return _isolate_helper.IsolateNatives.spawnFunction(entryPoint, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx.get](1)), {pauseCapability: isolate.Capability._check(msg[dartx.get](2)), terminateCapability: isolate.Capability._check(msg[dartx.get](3))}), ListToIsolate()));
+ return _isolate_helper.IsolateNatives.spawnFunction(entryPoint, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx._get](1)), {pauseCapability: isolate.Capability._check(msg[dartx._get](2)), terminateCapability: isolate.Capability._check(msg[dartx._get](3))}), ListToIsolate()));
} catch (e) {
let st = dart.stackTrace(e);
return FutureOfIsolate().error(e, st);
@@ -36309,14 +36308,14 @@
try {
if (core.List.is(args)) {
for (let i = 0; i < dart.notNull(args[dartx.length]); i++) {
- if (!(typeof args[dartx.get](i) == 'string')) {
+ if (!(typeof args[dartx._get](i) == 'string')) {
dart.throw(new core.ArgumentError(dart.str`Args must be a list of Strings ${args}`));
}
}
} else if (args != null) {
dart.throw(new core.ArgumentError(dart.str`Args must be a list of Strings ${args}`));
}
- return _isolate_helper.IsolateNatives.spawnUri(uri, args, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx.get](1)), {pauseCapability: isolate.Capability._check(msg[dartx.get](2)), terminateCapability: isolate.Capability._check(msg[dartx.get](3))}), ListToIsolate()));
+ return _isolate_helper.IsolateNatives.spawnUri(uri, args, message, paused).then(isolate.Isolate)(dart.fn(msg => new isolate.Isolate(isolate.SendPort._check(msg[dartx._get](1)), {pauseCapability: isolate.Capability._check(msg[dartx._get](2)), terminateCapability: isolate.Capability._check(msg[dartx._get](3))}), ListToIsolate()));
} catch (e) {
let st = dart.stackTrace(e);
return FutureOfIsolate().error(e, st);
@@ -36331,34 +36330,34 @@
}
[_pause](resumeCapability) {
let message = core.List.new(3);
- message[dartx.set](0, "pause");
- message[dartx.set](1, this.pauseCapability);
- message[dartx.set](2, resumeCapability);
+ message[dartx._set](0, "pause");
+ message[dartx._set](1, this.pauseCapability);
+ message[dartx._set](2, resumeCapability);
this.controlPort.send(message);
}
resume(resumeCapability) {
let message = core.List.new(2);
- message[dartx.set](0, "resume");
- message[dartx.set](1, resumeCapability);
+ message[dartx._set](0, "resume");
+ message[dartx._set](1, resumeCapability);
this.controlPort.send(message);
}
addOnExitListener(responsePort) {
let message = core.List.new(2);
- message[dartx.set](0, "add-ondone");
- message[dartx.set](1, responsePort);
+ message[dartx._set](0, "add-ondone");
+ message[dartx._set](1, responsePort);
this.controlPort.send(message);
}
removeOnExitListener(responsePort) {
let message = core.List.new(2);
- message[dartx.set](0, "remove-ondone");
- message[dartx.set](1, responsePort);
+ message[dartx._set](0, "remove-ondone");
+ message[dartx._set](1, responsePort);
this.controlPort.send(message);
}
setErrorsFatal(errorsAreFatal) {
let message = core.List.new(3);
- message[dartx.set](0, "set-errors-fatal");
- message[dartx.set](1, this.terminateCapability);
- message[dartx.set](2, errorsAreFatal);
+ message[dartx._set](0, "set-errors-fatal");
+ message[dartx._set](1, this.terminateCapability);
+ message[dartx._set](2, errorsAreFatal);
this.controlPort.send(message);
}
kill(priority) {
@@ -36368,21 +36367,21 @@
ping(responsePort, pingType) {
if (pingType === void 0) pingType = isolate.Isolate.IMMEDIATE;
let message = core.List.new(3);
- message[dartx.set](0, "ping");
- message[dartx.set](1, responsePort);
- message[dartx.set](2, pingType);
+ message[dartx._set](0, "ping");
+ message[dartx._set](1, responsePort);
+ message[dartx._set](2, pingType);
this.controlPort.send(message);
}
addErrorListener(port) {
let message = core.List.new(2);
- message[dartx.set](0, "getErrors");
- message[dartx.set](1, port);
+ message[dartx._set](0, "getErrors");
+ message[dartx._set](1, port);
this.controlPort.send(message);
}
removeErrorListener(port) {
let message = core.List.new(2);
- message[dartx.set](0, "stopErrors");
- message[dartx.set](1, port);
+ message[dartx._set](0, "stopErrors");
+ message[dartx._set](1, port);
this.controlPort.send(message);
}
get errors() {
@@ -36573,18 +36572,18 @@
let _convertedObjects = collection.HashMap.identity();
function _convert(o) {
if (dart.test(_convertedObjects.containsKey(o))) {
- return _convertedObjects.get(o);
+ return _convertedObjects._get(o);
}
if (core.Map.is(o)) {
let convertedMap = {};
- _convertedObjects.set(o, convertedMap);
+ _convertedObjects._set(o, convertedMap);
for (let key of o[dartx.keys]) {
- convertedMap[key] = _convert(o[dartx.get](key));
+ convertedMap[key] = _convert(o[dartx._get](key));
}
return convertedMap;
} else if (core.Iterable.is(o)) {
let convertedList = [];
- _convertedObjects.set(o, convertedList);
+ _convertedObjects._set(o, convertedList);
convertedList[dartx.addAll](o[dartx.map](dart.dynamic)(_convert));
return convertedList;
} else {
@@ -36594,13 +36593,13 @@
dart.fn(_convert, dynamicTodynamic$());
return _convert(data);
}
- get(property) {
+ _get(property) {
if (!(typeof property == 'string') && !(typeof property == 'number')) {
dart.throw(new core.ArgumentError("property is not a String or num"));
}
return js._convertToDart(this[_jsObject][property]);
}
- set(property, value) {
+ _set(property, value) {
if (!(typeof property == 'string') && !(typeof property == 'number')) {
dart.throw(new core.ArgumentError("property is not a String or num"));
}
@@ -36659,8 +36658,8 @@
}),
fields: () => ({[_jsObject]: dart.dynamic}),
methods: () => ({
- get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
- set: dart.definiteFunctionType(dart.dynamic, [core.Object, dart.dynamic]),
+ _get: dart.definiteFunctionType(dart.dynamic, [core.Object]),
+ _set: dart.definiteFunctionType(dart.dynamic, [core.Object, dart.dynamic]),
hasProperty: dart.definiteFunctionType(core.bool, [dart.dynamic]),
deleteProperty: dart.definiteFunctionType(dart.void, [dart.dynamic]),
instanceof: dart.definiteFunctionType(core.bool, [js.JsFunction]),
@@ -36734,18 +36733,18 @@
dart.throw(new core.RangeError.range(end, start, length));
}
}
- get(index) {
+ _get(index) {
if (typeof index == 'number' && index == index[dartx.toInt]()) {
this[_checkIndex](dart.asInt(index));
}
- return E.as(super.get(index));
+ return E.as(super._get(index));
}
- set(index, value) {
+ _set(index, value) {
E._check(value);
if (typeof index == 'number' && index == index[dartx.toInt]()) {
this[_checkIndex](dart.asInt(index));
}
- super.set(index, value);
+ super._set(index, value);
return value;
}
get length() {
@@ -36756,7 +36755,7 @@
dart.throw(new core.StateError('Bad JsArray length'));
}
set length(length) {
- super.set('length', length);
+ super._set('length', length);
}
add(value) {
E._check(value);
@@ -36814,8 +36813,8 @@
methods: () => ({
[_checkIndex]: dart.definiteFunctionType(dart.dynamic, [core.int]),
[_checkInsertIndex]: dart.definiteFunctionType(dart.dynamic, [core.int]),
- get: dart.definiteFunctionType(E, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.Object, E]),
+ _get: dart.definiteFunctionType(E, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.Object, E]),
add: dart.definiteFunctionType(dart.void, [E]),
addAll: dart.definiteFunctionType(dart.void, [IterableOfE()]),
insert: dart.definiteFunctionType(dart.void, [core.int, E]),
@@ -36828,8 +36827,8 @@
names: ['_checkRange']
});
dart.defineExtensionMembers(JsArray, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'add',
'addAll',
'insert',
@@ -36936,7 +36935,7 @@
set _interopCaptureThisExpando(_) {}
});
js.allowInteropCaptureThis = function(f) {
- let ret = js._interopCaptureThisExpando.get(f);
+ let ret = js._interopCaptureThisExpando._get(f);
if (ret == null) {
ret = function() {
let args = [this];
@@ -36945,7 +36944,7 @@
}
return f(...args);
};
- js._interopCaptureThisExpando.set(f, ret);
+ js._interopCaptureThisExpando._set(f, ret);
}
return ret;
};
@@ -36961,18 +36960,18 @@
let _convertedObjects = collection.HashMap.identity();
function _convert(o) {
if (dart.test(_convertedObjects.containsKey(o))) {
- return _convertedObjects.get(o);
+ return _convertedObjects._get(o);
}
if (core.Map.is(o)) {
let convertedMap = {};
- _convertedObjects.set(o, convertedMap);
+ _convertedObjects._set(o, convertedMap);
for (let key of o[dartx.keys]) {
- convertedMap[key] = _convert(o[dartx.get](key));
+ convertedMap[key] = _convert(o[dartx._get](key));
}
return convertedMap;
} else if (core.Iterable.is(o)) {
let convertedList = [];
- _convertedObjects.set(o, convertedList);
+ _convertedObjects._set(o, convertedList);
convertedList[dartx.addAll](o[dartx.map](dart.dynamic)(_convert));
return convertedList;
} else {
@@ -37583,11 +37582,35 @@
'height'
]);
class Rectangle extends math._RectangleBase$(T) {
+ get left() {
+ return this[left$];
+ }
+ set left(value) {
+ super.left = value;
+ }
+ get top() {
+ return this[top$];
+ }
+ set top(value) {
+ super.top = value;
+ }
+ get width() {
+ return this[width$];
+ }
+ set width(value) {
+ super.width = value;
+ }
+ get height() {
+ return this[height$];
+ }
+ set height(value) {
+ super.height = value;
+ }
new(left, top, width, height) {
- this[dartx.left] = left;
- this[dartx.top] = top;
- this[dartx.width] = dart.notNull(width) < 0 ? -dart.notNull(width) * 0 : width;
- this[dartx.height] = dart.notNull(height) < 0 ? -dart.notNull(height) * 0 : height;
+ this[left$] = left;
+ this[top$] = top;
+ this[width$] = dart.notNull(width) < 0 ? -dart.notNull(width) * 0 : width;
+ this[height$] = dart.notNull(height) < 0 ? -dart.notNull(height) * 0 : height;
super.new();
}
static fromPoints(a, b) {
@@ -37598,6 +37621,10 @@
return new (RectangleOfT())(left, top, width, height);
}
}
+ const left$ = Symbol(Rectangle.name + "." + 'left'.toString());
+ const top$ = Symbol(Rectangle.name + "." + 'top'.toString());
+ const width$ = Symbol(Rectangle.name + "." + 'width'.toString());
+ const height$ = Symbol(Rectangle.name + "." + 'height'.toString());
dart.setSignature(Rectangle, {
constructors: () => ({
new: dart.definiteFunctionType(math.Rectangle$(T), [T, T, T, T]),
@@ -37621,9 +37648,21 @@
let RectangleOfT = () => (RectangleOfT = dart.constFn(math.Rectangle$(T)))();
let PointOfT = () => (PointOfT = dart.constFn(math.Point$(T)))();
class MutableRectangle extends math._RectangleBase$(T) {
+ get left() {
+ return this[left$];
+ }
+ set left(value) {
+ this[left$] = value;
+ }
+ get top() {
+ return this[top$];
+ }
+ set top(value) {
+ this[top$] = value;
+ }
new(left, top, width, height) {
- this.left = left;
- this.top = top;
+ this[left$] = left;
+ this[top$] = top;
this[_width] = dart.notNull(width) < 0 ? math._clampToZero(T)(width) : width;
this[_height] = dart.notNull(height) < 0 ? math._clampToZero(T)(height) : height;
super.new();
@@ -37652,6 +37691,8 @@
this[_height] = height;
}
}
+ const left$ = Symbol(MutableRectangle.name + "." + 'left'.toString());
+ const top$ = Symbol(MutableRectangle.name + "." + 'top'.toString());
MutableRectangle[dart.implements] = () => [RectangleOfT()];
dart.setSignature(MutableRectangle, {
constructors: () => ({
@@ -38230,7 +38271,7 @@
if (dart.test(html_common.isJavaScriptDate(object))) return true;
if (core.List.is(object)) {
for (let i = 0; i < dart.notNull(object[dartx.length]); i++) {
- if (dart.test(containsDate(object[dartx.get](i)))) return true;
+ if (dart.test(containsDate(object[dartx._get](i)))) return true;
}
}
return false;
@@ -38449,10 +38490,10 @@
let autoIncrement = opts && 'autoIncrement' in opts ? opts.autoIncrement : null;
let options = dart.map();
if (keyPath != null) {
- options[dartx.set]('keyPath', keyPath);
+ options[dartx._set]('keyPath', keyPath);
}
if (autoIncrement != null) {
- options[dartx.set]('autoIncrement', autoIncrement);
+ options[dartx._set]('autoIncrement', autoIncrement);
}
return this[_createObjectStore](name, options);
}
@@ -39044,10 +39085,10 @@
let multiEntry = opts && 'multiEntry' in opts ? opts.multiEntry : null;
let options = dart.map();
if (unique != null) {
- options[dartx.set]('unique', unique);
+ options[dartx._set]('unique', unique);
}
if (multiEntry != null) {
- options[dartx.set]('multiEntry', multiEntry);
+ options[dartx._set]('multiEntry', multiEntry);
}
return this[_createIndex](name, keyPath, options);
}
@@ -40226,7 +40267,7 @@
let attributes = this[dartx.attributes];
attributes[dartx.clear]();
for (let key of value[dartx.keys]) {
- attributes[dartx.set](key, value[dartx.get](key));
+ attributes[dartx._set](key, value[dartx._get](key));
}
}
get [dartx.children]() {
@@ -40266,7 +40307,7 @@
let data = this[dartx.dataset];
data[dartx.clear]();
for (let key of value[dartx.keys]) {
- data[dartx.set](key, value[dartx.get](key));
+ data[dartx._set](key, value[dartx._get](key));
}
}
[dartx.getNamespacedAttributes](namespace) {
@@ -40415,7 +40456,7 @@
}
case 'afterbegin':
{
- let first = dart.notNull(this[dartx.nodes][dartx.length]) > 0 ? this[dartx.nodes][dartx.get](0) : null;
+ let first = dart.notNull(this[dartx.nodes][dartx.length]) > 0 ? this[dartx.nodes][dartx._get](0) : null;
this[dartx.insertBefore](node, first);
break;
}
@@ -53165,7 +53206,7 @@
'clear',
'item',
'remove',
- 'get',
+ '_get',
'length'
]);
html$.DataTransferItemList = class DataTransferItemList extends _interceptors.Interceptor {
@@ -53193,7 +53234,7 @@
[dartx.remove](index) {
return this.remove(index);
}
- [dartx.get](index) {
+ [dartx._get](index) {
return this[index];
}
};
@@ -53207,7 +53248,7 @@
[dartx.clear]: dart.definiteFunctionType(dart.void, []),
[dartx.item]: dart.definiteFunctionType(html$.DataTransferItem, [core.int]),
[dartx.remove]: dart.definiteFunctionType(dart.void, [core.int]),
- [dartx.get]: dart.definiteFunctionType(html$.DataTransferItem, [core.int])
+ [dartx._get]: dart.definiteFunctionType(html$.DataTransferItem, [core.int])
})
});
dart.registerExtension(dart.global.DataTransferItemList, html$.DataTransferItemList);
@@ -56038,8 +56079,8 @@
html$.ImmutableListMixin = ImmutableListMixin();
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -56054,11 +56095,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.item](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -56087,7 +56128,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__getter__](index) {
return this.__getter__(index);
@@ -56107,8 +56148,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.String, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
[dartx.elementAt]: dart.definiteFunctionType(core.String, [core.int]),
[__getter__]: dart.definiteFunctionType(core.String, [core.int]),
[dartx.item]: dart.definiteFunctionType(core.String, [core.int])
@@ -56149,11 +56190,11 @@
get length() {
return this[_childElements][dartx.length];
}
- get(index) {
- return html$.Element._check(this[_childElements][dartx.get](index));
+ _get(index) {
+ return html$.Element._check(this[_childElements][dartx._get](index));
}
- set(index, value) {
- this[_element$][_replaceChild](value, this[_childElements][dartx.get](index));
+ _set(index, value) {
+ this[_element$][_replaceChild](value, this[_childElements][dartx._get](index));
return value;
}
set length(newLength) {
@@ -56226,7 +56267,7 @@
if (index == this.length) {
this[_element$][dartx.append](element);
} else {
- this[_element$][dartx.insertBefore](element, this.get(index));
+ this[_element$][dartx.insertBefore](element, this._get(index));
}
}
setAll(index, iterable) {
@@ -56236,7 +56277,7 @@
this[_element$][_clearChildren]();
}
removeAt(index) {
- let result = this.get(index);
+ let result = this._get(index);
if (result != null) {
this[_element$][_removeChild](result);
}
@@ -56286,8 +56327,8 @@
}),
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- get: dart.definiteFunctionType(html$.Element, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
+ _get: dart.definiteFunctionType(html$.Element, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
add: dart.definiteFunctionType(html$.Element, [html$.Element]),
addAll: dart.definiteFunctionType(dart.void, [IterableOfElement()]),
sort: dart.definiteFunctionType(dart.void, [], [ElementAndElementToint()]),
@@ -56305,8 +56346,8 @@
});
dart.defineExtensionMembers(html$._ChildrenElementList, [
'contains',
- 'get',
- 'set',
+ '_get',
+ '_set',
'add',
'addAll',
'sort',
@@ -56348,10 +56389,10 @@
get length() {
return this[_nodeList][dartx.length];
}
- get(index) {
- return html$._downcast(html$.Node, E)(this[_nodeList][dartx.get](index));
+ _get(index) {
+ return html$._downcast(html$.Node, E)(this[_nodeList][dartx._get](index));
}
- set(index, value) {
+ _set(index, value) {
E._check(value);
dart.throw(new core.UnsupportedError('Cannot modify list'));
return value;
@@ -56700,14 +56741,14 @@
classes: dart.definiteFunctionType(dart.void, [IterableOfString()])
}),
methods: () => ({
- get: dart.definiteFunctionType(E, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _get: dart.definiteFunctionType(E, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
sort: dart.definiteFunctionType(dart.void, [], [ComparatorOfE()])
})
});
dart.defineExtensionMembers(_FrozenElementList, [
- 'get',
- 'set',
+ '_get',
+ '_set',
'sort',
'shuffle',
'length',
@@ -57013,23 +57054,23 @@
new(ptr) {
this[_ptr] = ptr;
}
- get(type) {
+ _get(type) {
return new (_EventStreamOfEvent())(this[_ptr], type, false);
}
};
dart.setSignature(html$.Events, {
constructors: () => ({new: dart.definiteFunctionType(html$.Events, [html$.EventTarget])}),
fields: () => ({[_ptr]: html$.EventTarget}),
- methods: () => ({get: dart.definiteFunctionType(async.Stream, [core.String])})
+ methods: () => ({_get: dart.definiteFunctionType(async.Stream, [core.String])})
});
html$.ElementEvents = class ElementEvents extends html$.Events {
new(ptr) {
super.new(ptr);
}
- get(type) {
+ _get(type) {
if (dart.test(html$.ElementEvents.webkitEvents[dartx.keys][dartx.contains](type[dartx.toLowerCase]()))) {
if (dart.test(html_common.Device.isWebKit)) {
- return new (_ElementEventStreamImplOfEvent())(this[_ptr], html$.ElementEvents.webkitEvents[dartx.get](type[dartx.toLowerCase]()), false);
+ return new (_ElementEventStreamImplOfEvent())(this[_ptr], html$.ElementEvents.webkitEvents[dartx._get](type[dartx.toLowerCase]()), false);
}
}
return new (_ElementEventStreamImplOfEvent())(this[_ptr], type, false);
@@ -57412,8 +57453,8 @@
dart.registerExtension(dart.global.FileError, html$.FileError);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -57428,11 +57469,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -57461,7 +57502,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -57478,8 +57519,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.File, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.File]),
+ [dartx._get]: dart.definiteFunctionType(html$.File, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.File]),
[dartx.elementAt]: dart.definiteFunctionType(html$.File, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.File, [core.int])
})
@@ -58412,13 +58453,13 @@
let maximumAge = opts && 'maximumAge' in opts ? opts.maximumAge : null;
let options = dart.map();
if (enableHighAccuracy != null) {
- options[dartx.set]('enableHighAccuracy', enableHighAccuracy);
+ options[dartx._set]('enableHighAccuracy', enableHighAccuracy);
}
if (timeout != null) {
- options[dartx.set]('timeout', timeout.inMilliseconds);
+ options[dartx._set]('timeout', timeout.inMilliseconds);
}
if (maximumAge != null) {
- options[dartx.set]('maximumAge', maximumAge.inMilliseconds);
+ options[dartx._set]('maximumAge', maximumAge.inMilliseconds);
}
let completer = CompleterOfGeoposition().new();
try {
@@ -58440,13 +58481,13 @@
let maximumAge = opts && 'maximumAge' in opts ? opts.maximumAge : null;
let options = dart.map();
if (enableHighAccuracy != null) {
- options[dartx.set]('enableHighAccuracy', enableHighAccuracy);
+ options[dartx._set]('enableHighAccuracy', enableHighAccuracy);
}
if (timeout != null) {
- options[dartx.set]('timeout', timeout.inMilliseconds);
+ options[dartx._set]('timeout', timeout.inMilliseconds);
}
if (maximumAge != null) {
- options[dartx.set]('maximumAge', maximumAge.inMilliseconds);
+ options[dartx._set]('maximumAge', maximumAge.inMilliseconds);
}
let watchId = null;
let controller = null;
@@ -59486,8 +59527,8 @@
dart.registerExtension(dart.global.HMDVRDevice, html$.HmdvrDevice);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -59503,11 +59544,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -59536,7 +59577,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -59556,8 +59597,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Node, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
+ [dartx._get]: dart.definiteFunctionType(html$.Node, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Node, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.Node, [core.int]),
[dartx.namedItem]: dart.definiteFunctionType(core.Object, [core.String])
@@ -59991,9 +60032,9 @@
let key = header[dartx.substring](0, splitIdx)[dartx.toLowerCase]();
let value = header[dartx.substring](dart.notNull(splitIdx) + 2);
if (dart.test(headers[dartx.containsKey](key))) {
- headers[dartx.set](key, dart.str`${headers[dartx.get](key)}, ${value}`);
+ headers[dartx._set](key, dart.str`${headers[dartx._get](key)}, ${value}`);
} else {
- headers[dartx.set](key, value);
+ headers[dartx._set](key, value);
}
}
return headers;
@@ -61049,14 +61090,56 @@
]);
html$.InputElementBase = class InputElementBase extends core.Object {
new() {
- this[dartx.autofocus] = null;
- this[dartx.disabled] = null;
- this[dartx.incremental] = null;
- this[dartx.indeterminate] = null;
- this[dartx.name] = null;
- this[dartx.value] = null;
+ this[autofocus] = null;
+ this[disabled] = null;
+ this[incremental] = null;
+ this[indeterminate] = null;
+ this[name] = null;
+ this[value$] = null;
+ }
+ get autofocus() {
+ return this[autofocus];
+ }
+ set autofocus(value) {
+ this[autofocus] = value;
+ }
+ get disabled() {
+ return this[disabled];
+ }
+ set disabled(value) {
+ this[disabled] = value;
+ }
+ get incremental() {
+ return this[incremental];
+ }
+ set incremental(value) {
+ this[incremental] = value;
+ }
+ get indeterminate() {
+ return this[indeterminate];
+ }
+ set indeterminate(value) {
+ this[indeterminate] = value;
+ }
+ get name() {
+ return this[name];
+ }
+ set name(value) {
+ this[name] = value;
+ }
+ get value() {
+ return this[value$];
+ }
+ set value(value) {
+ this[value$] = value;
}
};
+ const autofocus = Symbol(html$.InputElementBase.name + "." + 'autofocus'.toString());
+ const disabled = Symbol(html$.InputElementBase.name + "." + 'disabled'.toString());
+ const incremental = Symbol(html$.InputElementBase.name + "." + 'incremental'.toString());
+ const indeterminate = Symbol(html$.InputElementBase.name + "." + 'indeterminate'.toString());
+ const name = Symbol(html$.InputElementBase.name + "." + 'name'.toString());
+ const value$ = Symbol(html$.InputElementBase.name + "." + 'value'.toString());
html$.InputElementBase[dart.implements] = () => [html$.Element];
dart.setSignature(html$.InputElementBase, {
fields: () => ({
@@ -61105,18 +61188,88 @@
]);
html$.TextInputElementBase = class TextInputElementBase extends core.Object {
new() {
- this[dartx.autocomplete] = null;
- this[dartx.maxLength] = null;
- this[dartx.pattern] = null;
- this[dartx.placeholder] = null;
- this[dartx.readOnly] = null;
- this[dartx.required] = null;
- this[dartx.size] = null;
- this[dartx.selectionDirection] = null;
- this[dartx.selectionEnd] = null;
- this[dartx.selectionStart] = null;
+ this[autocomplete] = null;
+ this[maxLength] = null;
+ this[pattern] = null;
+ this[placeholder] = null;
+ this[readOnly] = null;
+ this[required] = null;
+ this[size] = null;
+ this[selectionDirection] = null;
+ this[selectionEnd] = null;
+ this[selectionStart] = null;
+ }
+ get autocomplete() {
+ return this[autocomplete];
+ }
+ set autocomplete(value) {
+ this[autocomplete] = value;
+ }
+ get maxLength() {
+ return this[maxLength];
+ }
+ set maxLength(value) {
+ this[maxLength] = value;
+ }
+ get pattern() {
+ return this[pattern];
+ }
+ set pattern(value) {
+ this[pattern] = value;
+ }
+ get placeholder() {
+ return this[placeholder];
+ }
+ set placeholder(value) {
+ this[placeholder] = value;
+ }
+ get readOnly() {
+ return this[readOnly];
+ }
+ set readOnly(value) {
+ this[readOnly] = value;
+ }
+ get required() {
+ return this[required];
+ }
+ set required(value) {
+ this[required] = value;
+ }
+ get size() {
+ return this[size];
+ }
+ set size(value) {
+ this[size] = value;
+ }
+ get selectionDirection() {
+ return this[selectionDirection];
+ }
+ set selectionDirection(value) {
+ this[selectionDirection] = value;
+ }
+ get selectionEnd() {
+ return this[selectionEnd];
+ }
+ set selectionEnd(value) {
+ this[selectionEnd] = value;
+ }
+ get selectionStart() {
+ return this[selectionStart];
+ }
+ set selectionStart(value) {
+ this[selectionStart] = value;
}
};
+ const autocomplete = Symbol(html$.TextInputElementBase.name + "." + 'autocomplete'.toString());
+ const maxLength = Symbol(html$.TextInputElementBase.name + "." + 'maxLength'.toString());
+ const pattern = Symbol(html$.TextInputElementBase.name + "." + 'pattern'.toString());
+ const placeholder = Symbol(html$.TextInputElementBase.name + "." + 'placeholder'.toString());
+ const readOnly = Symbol(html$.TextInputElementBase.name + "." + 'readOnly'.toString());
+ const required = Symbol(html$.TextInputElementBase.name + "." + 'required'.toString());
+ const size = Symbol(html$.TextInputElementBase.name + "." + 'size'.toString());
+ const selectionDirection = Symbol(html$.TextInputElementBase.name + "." + 'selectionDirection'.toString());
+ const selectionEnd = Symbol(html$.TextInputElementBase.name + "." + 'selectionEnd'.toString());
+ const selectionStart = Symbol(html$.TextInputElementBase.name + "." + 'selectionStart'.toString());
html$.TextInputElementBase[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.TextInputElementBase, {
fields: () => ({
@@ -61161,10 +61314,17 @@
static new() {
return html$.InputElement.new({type: 'search'});
}
+ get dirName() {
+ return this[dirName];
+ }
+ set dirName(value) {
+ this[dirName] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'search'})[dartx.type] == 'search';
}
};
+ const dirName = Symbol(html$.SearchInputElement.name + "." + 'dirName'.toString());
html$.SearchInputElement[dart.implements] = () => [html$.TextInputElementBase];
dart.setSignature(html$.SearchInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.SearchInputElement, [])}),
@@ -61179,7 +61339,14 @@
static new() {
return html$.InputElement.new({type: 'text'});
}
+ get dirName() {
+ return this[dirName$];
+ }
+ set dirName(value) {
+ this[dirName$] = value;
+ }
};
+ const dirName$ = Symbol(html$.TextInputElement.name + "." + 'dirName'.toString());
html$.TextInputElement[dart.implements] = () => [html$.TextInputElementBase];
dart.setSignature(html$.TextInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.TextInputElement, [])}),
@@ -61227,10 +61394,73 @@
static new() {
return html$.InputElement.new({type: 'email'});
}
+ get autocomplete() {
+ return this[autocomplete$];
+ }
+ set autocomplete(value) {
+ this[autocomplete$] = value;
+ }
+ get autofocus() {
+ return this[autofocus$];
+ }
+ set autofocus(value) {
+ this[autofocus$] = value;
+ }
+ get maxLength() {
+ return this[maxLength$];
+ }
+ set maxLength(value) {
+ this[maxLength$] = value;
+ }
+ get multiple() {
+ return this[multiple];
+ }
+ set multiple(value) {
+ this[multiple] = value;
+ }
+ get pattern() {
+ return this[pattern$];
+ }
+ set pattern(value) {
+ this[pattern$] = value;
+ }
+ get placeholder() {
+ return this[placeholder$];
+ }
+ set placeholder(value) {
+ this[placeholder$] = value;
+ }
+ get readOnly() {
+ return this[readOnly$];
+ }
+ set readOnly(value) {
+ this[readOnly$] = value;
+ }
+ get required() {
+ return this[required$];
+ }
+ set required(value) {
+ this[required$] = value;
+ }
+ get size() {
+ return this[size$];
+ }
+ set size(value) {
+ this[size$] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'email'})[dartx.type] == 'email';
}
};
+ const autocomplete$ = Symbol(html$.EmailInputElement.name + "." + 'autocomplete'.toString());
+ const autofocus$ = Symbol(html$.EmailInputElement.name + "." + 'autofocus'.toString());
+ const maxLength$ = Symbol(html$.EmailInputElement.name + "." + 'maxLength'.toString());
+ const multiple = Symbol(html$.EmailInputElement.name + "." + 'multiple'.toString());
+ const pattern$ = Symbol(html$.EmailInputElement.name + "." + 'pattern'.toString());
+ const placeholder$ = Symbol(html$.EmailInputElement.name + "." + 'placeholder'.toString());
+ const readOnly$ = Symbol(html$.EmailInputElement.name + "." + 'readOnly'.toString());
+ const required$ = Symbol(html$.EmailInputElement.name + "." + 'required'.toString());
+ const size$ = Symbol(html$.EmailInputElement.name + "." + 'size'.toString());
html$.EmailInputElement[dart.implements] = () => [html$.TextInputElementBase];
dart.setSignature(html$.EmailInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.EmailInputElement, [])}),
@@ -61284,12 +61514,40 @@
]);
html$.RangeInputElementBase = class RangeInputElementBase extends core.Object {
new() {
- this[dartx.max] = null;
- this[dartx.min] = null;
- this[dartx.step] = null;
- this[dartx.valueAsNumber] = null;
+ this[max] = null;
+ this[min] = null;
+ this[step] = null;
+ this[valueAsNumber] = null;
+ }
+ get max() {
+ return this[max];
+ }
+ set max(value) {
+ this[max] = value;
+ }
+ get min() {
+ return this[min];
+ }
+ set min(value) {
+ this[min] = value;
+ }
+ get step() {
+ return this[step];
+ }
+ set step(value) {
+ this[step] = value;
+ }
+ get valueAsNumber() {
+ return this[valueAsNumber];
+ }
+ set valueAsNumber(value) {
+ this[valueAsNumber] = value;
}
};
+ const max = Symbol(html$.RangeInputElementBase.name + "." + 'max'.toString());
+ const min = Symbol(html$.RangeInputElementBase.name + "." + 'min'.toString());
+ const step = Symbol(html$.RangeInputElementBase.name + "." + 'step'.toString());
+ const valueAsNumber = Symbol(html$.RangeInputElementBase.name + "." + 'valueAsNumber'.toString());
html$.RangeInputElementBase[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.RangeInputElementBase, {
fields: () => ({
@@ -61318,10 +61576,31 @@
static new() {
return html$.InputElement.new({type: 'date'});
}
+ get valueAsDate() {
+ return this[valueAsDate];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate] = value;
+ }
+ get readOnly() {
+ return this[readOnly$0];
+ }
+ set readOnly(value) {
+ this[readOnly$0] = value;
+ }
+ get required() {
+ return this[required$0];
+ }
+ set required(value) {
+ this[required$0] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'date'})[dartx.type] == 'date';
}
};
+ const valueAsDate = Symbol(html$.DateInputElement.name + "." + 'valueAsDate'.toString());
+ const readOnly$0 = Symbol(html$.DateInputElement.name + "." + 'readOnly'.toString());
+ const required$0 = Symbol(html$.DateInputElement.name + "." + 'required'.toString());
html$.DateInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.DateInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.DateInputElement, [])}),
@@ -61349,10 +61628,31 @@
static new() {
return html$.InputElement.new({type: 'month'});
}
+ get valueAsDate() {
+ return this[valueAsDate$];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate$] = value;
+ }
+ get readOnly() {
+ return this[readOnly$1];
+ }
+ set readOnly(value) {
+ this[readOnly$1] = value;
+ }
+ get required() {
+ return this[required$1];
+ }
+ set required(value) {
+ this[required$1] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'month'})[dartx.type] == 'month';
}
};
+ const valueAsDate$ = Symbol(html$.MonthInputElement.name + "." + 'valueAsDate'.toString());
+ const readOnly$1 = Symbol(html$.MonthInputElement.name + "." + 'readOnly'.toString());
+ const required$1 = Symbol(html$.MonthInputElement.name + "." + 'required'.toString());
html$.MonthInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.MonthInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.MonthInputElement, [])}),
@@ -61380,10 +61680,31 @@
static new() {
return html$.InputElement.new({type: 'week'});
}
+ get valueAsDate() {
+ return this[valueAsDate$0];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate$0] = value;
+ }
+ get readOnly() {
+ return this[readOnly$2];
+ }
+ set readOnly(value) {
+ this[readOnly$2] = value;
+ }
+ get required() {
+ return this[required$2];
+ }
+ set required(value) {
+ this[required$2] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'week'})[dartx.type] == 'week';
}
};
+ const valueAsDate$0 = Symbol(html$.WeekInputElement.name + "." + 'valueAsDate'.toString());
+ const readOnly$2 = Symbol(html$.WeekInputElement.name + "." + 'readOnly'.toString());
+ const required$2 = Symbol(html$.WeekInputElement.name + "." + 'required'.toString());
html$.WeekInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.WeekInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.WeekInputElement, [])}),
@@ -61411,10 +61732,31 @@
static new() {
return html$.InputElement.new({type: 'time'});
}
+ get valueAsDate() {
+ return this[valueAsDate$1];
+ }
+ set valueAsDate(value) {
+ this[valueAsDate$1] = value;
+ }
+ get readOnly() {
+ return this[readOnly$3];
+ }
+ set readOnly(value) {
+ this[readOnly$3] = value;
+ }
+ get required() {
+ return this[required$3];
+ }
+ set required(value) {
+ this[required$3] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'time'})[dartx.type] == 'time';
}
};
+ const valueAsDate$1 = Symbol(html$.TimeInputElement.name + "." + 'valueAsDate'.toString());
+ const readOnly$3 = Symbol(html$.TimeInputElement.name + "." + 'readOnly'.toString());
+ const required$3 = Symbol(html$.TimeInputElement.name + "." + 'required'.toString());
html$.TimeInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.TimeInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.TimeInputElement, [])}),
@@ -61441,10 +61783,24 @@
static new() {
return html$.InputElement.new({type: 'datetime-local'});
}
+ get readOnly() {
+ return this[readOnly$4];
+ }
+ set readOnly(value) {
+ this[readOnly$4] = value;
+ }
+ get required() {
+ return this[required$4];
+ }
+ set required(value) {
+ this[required$4] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'datetime-local'})[dartx.type] == 'datetime-local';
}
};
+ const readOnly$4 = Symbol(html$.LocalDateTimeInputElement.name + "." + 'readOnly'.toString());
+ const required$4 = Symbol(html$.LocalDateTimeInputElement.name + "." + 'required'.toString());
html$.LocalDateTimeInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.LocalDateTimeInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.LocalDateTimeInputElement, [])}),
@@ -61464,10 +61820,31 @@
static new() {
return html$.InputElement.new({type: 'number'});
}
+ get placeholder() {
+ return this[placeholder$0];
+ }
+ set placeholder(value) {
+ this[placeholder$0] = value;
+ }
+ get readOnly() {
+ return this[readOnly$5];
+ }
+ set readOnly(value) {
+ this[readOnly$5] = value;
+ }
+ get required() {
+ return this[required$5];
+ }
+ set required(value) {
+ this[required$5] = value;
+ }
static get supported() {
return html$.InputElement.new({type: 'number'})[dartx.type] == 'number';
}
};
+ const placeholder$0 = Symbol(html$.NumberInputElement.name + "." + 'placeholder'.toString());
+ const readOnly$5 = Symbol(html$.NumberInputElement.name + "." + 'readOnly'.toString());
+ const required$5 = Symbol(html$.NumberInputElement.name + "." + 'required'.toString());
html$.NumberInputElement[dart.implements] = () => [html$.RangeInputElementBase];
dart.setSignature(html$.NumberInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.NumberInputElement, [])}),
@@ -61507,7 +61884,21 @@
static new() {
return html$.InputElement.new({type: 'checkbox'});
}
+ get checked() {
+ return this[checked];
+ }
+ set checked(value) {
+ this[checked] = value;
+ }
+ get required() {
+ return this[required$6];
+ }
+ set required(value) {
+ this[required$6] = value;
+ }
};
+ const checked = Symbol(html$.CheckboxInputElement.name + "." + 'checked'.toString());
+ const required$6 = Symbol(html$.CheckboxInputElement.name + "." + 'required'.toString());
html$.CheckboxInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.CheckboxInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.CheckboxInputElement, [])}),
@@ -61525,7 +61916,21 @@
static new() {
return html$.InputElement.new({type: 'radio'});
}
+ get checked() {
+ return this[checked$];
+ }
+ set checked(value) {
+ this[checked$] = value;
+ }
+ get required() {
+ return this[required$7];
+ }
+ set required(value) {
+ this[required$7] = value;
+ }
};
+ const checked$ = Symbol(html$.RadioButtonInputElement.name + "." + 'checked'.toString());
+ const required$7 = Symbol(html$.RadioButtonInputElement.name + "." + 'required'.toString());
html$.RadioButtonInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.RadioButtonInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.RadioButtonInputElement, [])}),
@@ -61545,7 +61950,35 @@
static new() {
return html$.InputElement.new({type: 'file'});
}
+ get accept() {
+ return this[accept];
+ }
+ set accept(value) {
+ this[accept] = value;
+ }
+ get multiple() {
+ return this[multiple$];
+ }
+ set multiple(value) {
+ this[multiple$] = value;
+ }
+ get required() {
+ return this[required$8];
+ }
+ set required(value) {
+ this[required$8] = value;
+ }
+ get files() {
+ return this[files];
+ }
+ set files(value) {
+ this[files] = value;
+ }
};
+ const accept = Symbol(html$.FileUploadInputElement.name + "." + 'accept'.toString());
+ const multiple$ = Symbol(html$.FileUploadInputElement.name + "." + 'multiple'.toString());
+ const required$8 = Symbol(html$.FileUploadInputElement.name + "." + 'required'.toString());
+ const files = Symbol(html$.FileUploadInputElement.name + "." + 'files'.toString());
html$.FileUploadInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.FileUploadInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.FileUploadInputElement, [])}),
@@ -61577,7 +62010,42 @@
static new() {
return html$.InputElement.new({type: 'submit'});
}
+ get formAction() {
+ return this[formAction];
+ }
+ set formAction(value) {
+ this[formAction] = value;
+ }
+ get formEnctype() {
+ return this[formEnctype];
+ }
+ set formEnctype(value) {
+ this[formEnctype] = value;
+ }
+ get formMethod() {
+ return this[formMethod];
+ }
+ set formMethod(value) {
+ this[formMethod] = value;
+ }
+ get formNoValidate() {
+ return this[formNoValidate];
+ }
+ set formNoValidate(value) {
+ this[formNoValidate] = value;
+ }
+ get formTarget() {
+ return this[formTarget];
+ }
+ set formTarget(value) {
+ this[formTarget] = value;
+ }
};
+ const formAction = Symbol(html$.SubmitButtonInputElement.name + "." + 'formAction'.toString());
+ const formEnctype = Symbol(html$.SubmitButtonInputElement.name + "." + 'formEnctype'.toString());
+ const formMethod = Symbol(html$.SubmitButtonInputElement.name + "." + 'formMethod'.toString());
+ const formNoValidate = Symbol(html$.SubmitButtonInputElement.name + "." + 'formNoValidate'.toString());
+ const formTarget = Symbol(html$.SubmitButtonInputElement.name + "." + 'formTarget'.toString());
html$.SubmitButtonInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.SubmitButtonInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.SubmitButtonInputElement, [])}),
@@ -61616,7 +62084,70 @@
static new() {
return html$.InputElement.new({type: 'image'});
}
+ get alt() {
+ return this[alt];
+ }
+ set alt(value) {
+ this[alt] = value;
+ }
+ get formAction() {
+ return this[formAction$];
+ }
+ set formAction(value) {
+ this[formAction$] = value;
+ }
+ get formEnctype() {
+ return this[formEnctype$];
+ }
+ set formEnctype(value) {
+ this[formEnctype$] = value;
+ }
+ get formMethod() {
+ return this[formMethod$];
+ }
+ set formMethod(value) {
+ this[formMethod$] = value;
+ }
+ get formNoValidate() {
+ return this[formNoValidate$];
+ }
+ set formNoValidate(value) {
+ this[formNoValidate$] = value;
+ }
+ get formTarget() {
+ return this[formTarget$];
+ }
+ set formTarget(value) {
+ this[formTarget$] = value;
+ }
+ get height() {
+ return this[height];
+ }
+ set height(value) {
+ this[height] = value;
+ }
+ get src() {
+ return this[src];
+ }
+ set src(value) {
+ this[src] = value;
+ }
+ get width() {
+ return this[width];
+ }
+ set width(value) {
+ this[width] = value;
+ }
};
+ const alt = Symbol(html$.ImageButtonInputElement.name + "." + 'alt'.toString());
+ const formAction$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formAction'.toString());
+ const formEnctype$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formEnctype'.toString());
+ const formMethod$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formMethod'.toString());
+ const formNoValidate$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formNoValidate'.toString());
+ const formTarget$ = Symbol(html$.ImageButtonInputElement.name + "." + 'formTarget'.toString());
+ const height = Symbol(html$.ImageButtonInputElement.name + "." + 'height'.toString());
+ const src = Symbol(html$.ImageButtonInputElement.name + "." + 'src'.toString());
+ const width = Symbol(html$.ImageButtonInputElement.name + "." + 'width'.toString());
html$.ImageButtonInputElement[dart.implements] = () => [html$.InputElementBase];
dart.setSignature(html$.ImageButtonInputElement, {
constructors: () => ({new: dart.definiteFunctionType(html$.ImageButtonInputElement, [])}),
@@ -64190,8 +64721,8 @@
dart.registerExtension(dart.global.MimeType, html$.MimeType);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -64207,11 +64738,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -64240,7 +64771,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -64260,8 +64791,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.MimeType, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.MimeType]),
+ [dartx._get]: dart.definiteFunctionType(html$.MimeType, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.MimeType]),
[dartx.elementAt]: dart.definiteFunctionType(html$.MimeType, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.MimeType, [core.int]),
[dartx.namedItem]: dart.definiteFunctionType(html$.MimeType, [core.String])
@@ -64940,7 +65471,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get hardwareConcurrency() {
+ return this[hardwareConcurrency];
+ }
+ set hardwareConcurrency(value) {
+ super.hardwareConcurrency = value;
+ }
};
+ const hardwareConcurrency = Symbol(html$.NavigatorCpu.name + "." + 'hardwareConcurrency'.toString());
dart.setSignature(html$.NavigatorCpu, {
constructors: () => ({_: dart.definiteFunctionType(html$.NavigatorCpu, [])}),
fields: () => ({hardwareConcurrency: core.int})
@@ -64959,7 +65497,56 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get appCodeName() {
+ return this[appCodeName];
+ }
+ set appCodeName(value) {
+ super.appCodeName = value;
+ }
+ get appName() {
+ return this[appName];
+ }
+ set appName(value) {
+ super.appName = value;
+ }
+ get appVersion() {
+ return this[appVersion];
+ }
+ set appVersion(value) {
+ super.appVersion = value;
+ }
+ get dartEnabled() {
+ return this[dartEnabled];
+ }
+ set dartEnabled(value) {
+ super.dartEnabled = value;
+ }
+ get platform() {
+ return this[platform];
+ }
+ set platform(value) {
+ super.platform = value;
+ }
+ get product() {
+ return this[product];
+ }
+ set product(value) {
+ super.product = value;
+ }
+ get userAgent() {
+ return this[userAgent];
+ }
+ set userAgent(value) {
+ super.userAgent = value;
+ }
};
+ const appCodeName = Symbol(html$.NavigatorID.name + "." + 'appCodeName'.toString());
+ const appName = Symbol(html$.NavigatorID.name + "." + 'appName'.toString());
+ const appVersion = Symbol(html$.NavigatorID.name + "." + 'appVersion'.toString());
+ const dartEnabled = Symbol(html$.NavigatorID.name + "." + 'dartEnabled'.toString());
+ const platform = Symbol(html$.NavigatorID.name + "." + 'platform'.toString());
+ const product = Symbol(html$.NavigatorID.name + "." + 'product'.toString());
+ const userAgent = Symbol(html$.NavigatorID.name + "." + 'userAgent'.toString());
dart.setSignature(html$.NavigatorID, {
constructors: () => ({_: dart.definiteFunctionType(html$.NavigatorID, [])}),
fields: () => ({
@@ -64989,7 +65576,21 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get language() {
+ return this[language];
+ }
+ set language(value) {
+ super.language = value;
+ }
+ get languages() {
+ return this[languages];
+ }
+ set languages(value) {
+ super.languages = value;
+ }
};
+ const language = Symbol(html$.NavigatorLanguage.name + "." + 'language'.toString());
+ const languages = Symbol(html$.NavigatorLanguage.name + "." + 'languages'.toString());
dart.setSignature(html$.NavigatorLanguage, {
constructors: () => ({_: dart.definiteFunctionType(html$.NavigatorLanguage, [])}),
fields: () => ({
@@ -65005,7 +65606,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get onLine() {
+ return this[onLine];
+ }
+ set onLine(value) {
+ super.onLine = value;
+ }
};
+ const onLine = Symbol(html$.NavigatorOnLine.name + "." + 'onLine'.toString());
dart.setSignature(html$.NavigatorOnLine, {
constructors: () => ({_: dart.definiteFunctionType(html$.NavigatorOnLine, [])}),
fields: () => ({onLine: core.bool})
@@ -65122,14 +65730,14 @@
if (index == this.length) {
this[_this][dartx.append](node);
} else {
- this[_this][dartx.insertBefore](node, this.get(index));
+ this[_this][dartx.insertBefore](node, this._get(index));
}
}
insertAll(index, iterable) {
if (index == this.length) {
this.addAll(iterable);
} else {
- let item = this.get(index);
+ let item = this._get(index);
this[_this][dartx.insertAllBefore](iterable, item);
}
}
@@ -65144,7 +65752,7 @@
return result;
}
removeAt(index) {
- let result = this.get(index);
+ let result = this._get(index);
if (result != null) {
this[_this][_removeChild](result);
}
@@ -65176,8 +65784,8 @@
clear() {
this[_this][_clearChildren]();
}
- set(index, value) {
- this[_this][_replaceChild](value, this.get(index));
+ _set(index, value) {
+ this[_this][_replaceChild](value, this._get(index));
return value;
}
get iterator() {
@@ -65205,8 +65813,8 @@
set length(value) {
dart.throw(new core.UnsupportedError("Cannot set length on immutable List."));
}
- get(index) {
- return this[_this][dartx.childNodes][dartx.get](index);
+ _get(index) {
+ return this[_this][dartx.childNodes][dartx._get](index);
}
get rawList() {
return this[_this][dartx.childNodes];
@@ -65237,11 +65845,11 @@
[_filter$]: dart.definiteFunctionType(dart.void, [NodeTobool(), core.bool]),
removeWhere: dart.definiteFunctionType(dart.void, [NodeTobool()]),
retainWhere: dart.definiteFunctionType(dart.void, [NodeTobool()]),
- set: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
sort: dart.definiteFunctionType(dart.void, [], [ComparatorOfNode()]),
setRange: dart.definiteFunctionType(dart.void, [core.int, core.int, IterableOfNode()], [core.int]),
fillRange: dart.definiteFunctionType(dart.void, [core.int, core.int], [html$.Node]),
- get: dart.definiteFunctionType(html$.Node, [core.int])
+ _get: dart.definiteFunctionType(html$.Node, [core.int])
})
});
dart.defineExtensionMembers(html$._ChildNodeListLazy, [
@@ -65256,12 +65864,12 @@
'removeWhere',
'retainWhere',
'clear',
- 'set',
+ '_set',
'sort',
'shuffle',
'setRange',
'fillRange',
- 'get',
+ '_get',
'first',
'last',
'single',
@@ -65360,8 +65968,8 @@
dart.registerExtension(dart.global.NodeIterator, html$.NodeIterator);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -65375,11 +65983,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -65408,7 +66016,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[_item](index) {
return this.item(index);
@@ -65425,8 +66033,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Node, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
+ [dartx._get]: dart.definiteFunctionType(html$.Node, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Node, [core.int]),
[_item]: dart.definiteFunctionType(html$.Node, [core.int])
})
@@ -65497,11 +66105,11 @@
let tag = opts && 'tag' in opts ? opts.tag : null;
let icon = opts && 'icon' in opts ? opts.icon : null;
let parsedOptions = dart.map();
- if (dir != null) parsedOptions[dartx.set]('dir', dir);
- if (body != null) parsedOptions[dartx.set]('body', body);
- if (lang != null) parsedOptions[dartx.set]('lang', lang);
- if (tag != null) parsedOptions[dartx.set]('tag', tag);
- if (icon != null) parsedOptions[dartx.set]('icon', icon);
+ if (dir != null) parsedOptions[dartx._set]('dir', dir);
+ if (body != null) parsedOptions[dartx._set]('body', body);
+ if (lang != null) parsedOptions[dartx._set]('lang', lang);
+ if (tag != null) parsedOptions[dartx._set]('tag', tag);
+ if (icon != null) parsedOptions[dartx._set]('icon', icon);
return html$.Notification._factoryNotification(title, parsedOptions);
}
static _() {
@@ -67042,8 +67650,8 @@
dart.registerExtension(dart.global.Plugin, html$.Plugin);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -67060,11 +67668,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -67093,7 +67701,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -67116,8 +67724,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Plugin, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Plugin]),
+ [dartx._get]: dart.definiteFunctionType(html$.Plugin, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Plugin]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Plugin, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.Plugin, [core.int]),
[dartx.namedItem]: dart.definiteFunctionType(html$.Plugin, [core.String]),
@@ -69564,7 +70172,7 @@
let options = this[dartx.options][dartx.where](dart.fn(o => o[dartx.selected], OptionElementTobool()))[dartx.toList]();
return new (UnmodifiableListViewOfOptionElement())(options);
} else {
- return JSArrayOfOptionElement().of([this[dartx.options][dartx.get](this[dartx.selectedIndex])]);
+ return JSArrayOfOptionElement().of([this[dartx.options][dartx._get](this[dartx.selectedIndex])]);
}
}
};
@@ -70532,8 +71140,8 @@
dart.registerExtension(dart.global.SourceBuffer, html$.SourceBuffer);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -70548,11 +71156,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -70581,7 +71189,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -70598,8 +71206,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.SourceBuffer, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.SourceBuffer]),
+ [dartx._get]: dart.definiteFunctionType(html$.SourceBuffer, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.SourceBuffer]),
[dartx.elementAt]: dart.definiteFunctionType(html$.SourceBuffer, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.SourceBuffer, [core.int])
})
@@ -70769,8 +71377,8 @@
dart.registerExtension(dart.global.SpeechGrammar, html$.SpeechGrammar);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -70793,11 +71401,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -70826,7 +71434,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.addFromString](string, weight) {
return this.addFromString(string, weight);
@@ -70852,8 +71460,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.SpeechGrammar, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.SpeechGrammar]),
+ [dartx._get]: dart.definiteFunctionType(html$.SpeechGrammar, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.SpeechGrammar]),
[dartx.elementAt]: dart.definiteFunctionType(html$.SpeechGrammar, [core.int]),
[dartx.addFromString]: dart.definiteFunctionType(dart.void, [core.String], [core.num]),
[dartx.addFromUri]: dart.definiteFunctionType(dart.void, [core.String], [core.num]),
@@ -71545,8 +72153,8 @@
'addAll',
'containsValue',
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -71560,7 +72168,7 @@
html$.Storage = class Storage extends _interceptors.Interceptor {
[dartx.addAll](other) {
other[dartx.forEach](dart.fn((k, v) => {
- this[dartx.set](k, v);
+ this[dartx._set](k, v);
}, StringAndStringTovoid$()));
}
[dartx.containsValue](value) {
@@ -71569,19 +72177,19 @@
[dartx.containsKey](key) {
return this[_getItem](core.String._check(key)) != null;
}
- [dartx.get](key) {
+ [dartx._get](key) {
return this[_getItem](core.String._check(key));
}
- [dartx.set](key, value) {
+ [dartx._set](key, value) {
this[_setItem](key, value);
return value;
}
[dartx.putIfAbsent](key, ifAbsent) {
- if (!dart.test(this[dartx.containsKey](key))) this[dartx.set](key, ifAbsent());
- return this[dartx.get](key);
+ if (!dart.test(this[dartx.containsKey](key))) this[dartx._set](key, ifAbsent());
+ return this[dartx._get](key);
}
[dartx.remove](key) {
- let value = this[dartx.get](key);
+ let value = this[dartx._get](key);
this[_removeItem](core.String._check(key));
return value;
}
@@ -71592,7 +72200,7 @@
for (let i = 0; true; i++) {
let key = this[_key](i);
if (key == null) return;
- f(key, this[dartx.get](key));
+ f(key, this[dartx._get](key));
}
}
get [dartx.keys]() {
@@ -71660,8 +72268,8 @@
[dartx.addAll]: dart.definiteFunctionType(dart.void, [MapOfString$String()]),
[dartx.containsValue]: dart.definiteFunctionType(core.bool, [core.Object]),
[dartx.containsKey]: dart.definiteFunctionType(core.bool, [core.Object]),
- [dartx.get]: dart.definiteFunctionType(core.String, [core.Object]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.Object]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.String, core.String]),
[dartx.putIfAbsent]: dart.definiteFunctionType(core.String, [core.String, VoidToString()]),
[dartx.remove]: dart.definiteFunctionType(core.String, [core.Object]),
[dartx.clear]: dart.definiteFunctionType(dart.void, []),
@@ -72990,8 +73598,8 @@
dart.registerExtension(dart.global.TextTrackCue, html$.TextTrackCue);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -73007,11 +73615,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -73040,7 +73648,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.getCueById](id) {
return this.getCueById(id);
@@ -73060,8 +73668,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.TextTrackCue, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.TextTrackCue]),
+ [dartx._get]: dart.definiteFunctionType(html$.TextTrackCue, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.TextTrackCue]),
[dartx.elementAt]: dart.definiteFunctionType(html$.TextTrackCue, [core.int]),
[dartx.getCueById]: dart.definiteFunctionType(html$.TextTrackCue, [core.String]),
[dartx.item]: dart.definiteFunctionType(html$.TextTrackCue, [core.int])
@@ -73070,8 +73678,8 @@
dart.registerExtension(dart.global.TextTrackCueList, html$.TextTrackCueList);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -73089,11 +73697,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -73122,7 +73730,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.getTrackById](id) {
return this.getTrackById(id);
@@ -73150,8 +73758,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.TextTrack, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.TextTrack]),
+ [dartx._get]: dart.definiteFunctionType(html$.TextTrack, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.TextTrack]),
[dartx.elementAt]: dart.definiteFunctionType(html$.TextTrack, [core.int]),
[dartx.getTrackById]: dart.definiteFunctionType(html$.TextTrack, [core.String]),
[dartx.item]: dart.definiteFunctionType(html$.TextTrack, [core.int])
@@ -73436,8 +74044,8 @@
dart.registerExtension(dart.global.TouchEvent, html$.TouchEvent);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -73458,11 +74066,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -73491,7 +74099,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -73511,8 +74119,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Touch, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Touch]),
+ [dartx._get]: dart.definiteFunctionType(html$.Touch, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Touch]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Touch, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.Touch, [core.int])
}),
@@ -74064,7 +74672,84 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get hash() {
+ return this[hash];
+ }
+ set hash(value) {
+ this[hash] = value;
+ }
+ get host() {
+ return this[host];
+ }
+ set host(value) {
+ this[host] = value;
+ }
+ get hostname() {
+ return this[hostname];
+ }
+ set hostname(value) {
+ this[hostname] = value;
+ }
+ get href() {
+ return this[href];
+ }
+ set href(value) {
+ this[href] = value;
+ }
+ get origin() {
+ return this[origin];
+ }
+ set origin(value) {
+ super.origin = value;
+ }
+ get password() {
+ return this[password];
+ }
+ set password(value) {
+ this[password] = value;
+ }
+ get pathname() {
+ return this[pathname];
+ }
+ set pathname(value) {
+ this[pathname] = value;
+ }
+ get port() {
+ return this[port];
+ }
+ set port(value) {
+ this[port] = value;
+ }
+ get protocol() {
+ return this[protocol];
+ }
+ set protocol(value) {
+ this[protocol] = value;
+ }
+ get search() {
+ return this[search];
+ }
+ set search(value) {
+ this[search] = value;
+ }
+ get username() {
+ return this[username];
+ }
+ set username(value) {
+ this[username] = value;
+ }
};
+ const hash = Symbol(html$.UrlUtils.name + "." + 'hash'.toString());
+ const host = Symbol(html$.UrlUtils.name + "." + 'host'.toString());
+ const hostname = Symbol(html$.UrlUtils.name + "." + 'hostname'.toString());
+ const href = Symbol(html$.UrlUtils.name + "." + 'href'.toString());
+ const origin = Symbol(html$.UrlUtils.name + "." + 'origin'.toString());
+ const password = Symbol(html$.UrlUtils.name + "." + 'password'.toString());
+ const pathname = Symbol(html$.UrlUtils.name + "." + 'pathname'.toString());
+ const port = Symbol(html$.UrlUtils.name + "." + 'port'.toString());
+ const protocol = Symbol(html$.UrlUtils.name + "." + 'protocol'.toString());
+ const search = Symbol(html$.UrlUtils.name + "." + 'search'.toString());
+ const username = Symbol(html$.UrlUtils.name + "." + 'username'.toString());
dart.setSignature(html$.UrlUtils, {
constructors: () => ({_: dart.definiteFunctionType(html$.UrlUtils, [])}),
fields: () => ({
@@ -74119,7 +74804,70 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get hash() {
+ return this[hash$];
+ }
+ set hash(value) {
+ super.hash = value;
+ }
+ get host() {
+ return this[host$];
+ }
+ set host(value) {
+ super.host = value;
+ }
+ get hostname() {
+ return this[hostname$];
+ }
+ set hostname(value) {
+ super.hostname = value;
+ }
+ get href() {
+ return this[href$];
+ }
+ set href(value) {
+ super.href = value;
+ }
+ get origin() {
+ return this[origin$];
+ }
+ set origin(value) {
+ super.origin = value;
+ }
+ get pathname() {
+ return this[pathname$];
+ }
+ set pathname(value) {
+ super.pathname = value;
+ }
+ get port() {
+ return this[port$];
+ }
+ set port(value) {
+ super.port = value;
+ }
+ get protocol() {
+ return this[protocol$];
+ }
+ set protocol(value) {
+ super.protocol = value;
+ }
+ get search() {
+ return this[search$];
+ }
+ set search(value) {
+ super.search = value;
+ }
};
+ const hash$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'hash'.toString());
+ const host$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'host'.toString());
+ const hostname$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'hostname'.toString());
+ const href$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'href'.toString());
+ const origin$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'origin'.toString());
+ const pathname$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'pathname'.toString());
+ const port$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'port'.toString());
+ const protocol$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'protocol'.toString());
+ const search$ = Symbol(html$.UrlUtilsReadOnly.name + "." + 'search'.toString());
dart.setSignature(html$.UrlUtilsReadOnly, {
constructors: () => ({_: dart.definiteFunctionType(html$.UrlUtilsReadOnly, [])}),
fields: () => ({
@@ -77186,8 +77934,8 @@
});
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77202,11 +77950,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.item](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77235,7 +77983,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__getter__](index) {
return this.__getter__(index);
@@ -77255,8 +78003,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, RectangleOfnum()]),
+ [dartx._get]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, RectangleOfnum()]),
[dartx.elementAt]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
[__getter__]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int]),
[dartx.item]: dart.definiteFunctionType(math.Rectangle$(core.num), [core.int])
@@ -77266,8 +78014,8 @@
dart.registerExtension(dart.global.DOMRectList, html$._ClientRectList);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77282,11 +78030,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77315,7 +78063,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -77332,8 +78080,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.CssRule, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.CssRule]),
+ [dartx._get]: dart.definiteFunctionType(html$.CssRule, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.CssRule]),
[dartx.elementAt]: dart.definiteFunctionType(html$.CssRule, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.CssRule, [core.int])
})
@@ -77519,8 +78267,8 @@
dart.registerExtension(dart.global.FileWriterSync, html$._FileWriterSync);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77535,11 +78283,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77568,7 +78316,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -77585,8 +78333,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Gamepad, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Gamepad]),
+ [dartx._get]: dart.definiteFunctionType(html$.Gamepad, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Gamepad]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Gamepad, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.Gamepad, [core.int])
})
@@ -77704,8 +78452,8 @@
dart.registerExtension(dart.global.HTMLMarqueeElement, html$._HTMLMarqueeElement);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77726,11 +78474,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77759,7 +78507,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.getNamedItem](name) {
return this.getNamedItem(name);
@@ -77794,8 +78542,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.Node, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
+ [dartx._get]: dart.definiteFunctionType(html$.Node, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.Node]),
[dartx.elementAt]: dart.definiteFunctionType(html$.Node, [core.int]),
[dartx.getNamedItem]: dart.definiteFunctionType(html$._Attr, [core.String]),
[dartx.getNamedItemNS]: dart.definiteFunctionType(html$._Attr, [core.String, core.String]),
@@ -77938,8 +78686,8 @@
dart.registerExtension(dart.global.ServiceWorker, html$._ServiceWorker);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -77954,11 +78702,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -77987,7 +78735,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return this.item(index);
@@ -78004,8 +78752,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.SpeechRecognitionResult, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.SpeechRecognitionResult]),
+ [dartx._get]: dart.definiteFunctionType(html$.SpeechRecognitionResult, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.SpeechRecognitionResult]),
[dartx.elementAt]: dart.definiteFunctionType(html$.SpeechRecognitionResult, [core.int]),
[dartx.item]: dart.definiteFunctionType(html$.SpeechRecognitionResult, [core.int])
})
@@ -78013,8 +78761,8 @@
dart.registerExtension(dart.global.SpeechRecognitionResultList, html$._SpeechRecognitionResultList);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -78029,11 +78777,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[index];
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -78062,7 +78810,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__getter__](name) {
return this.__getter__(name);
@@ -78082,8 +78830,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(html$.StyleSheet, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, html$.StyleSheet]),
+ [dartx._get]: dart.definiteFunctionType(html$.StyleSheet, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, html$.StyleSheet]),
[dartx.elementAt]: dart.definiteFunctionType(html$.StyleSheet, [core.int]),
[__getter__]: dart.definiteFunctionType(html$.CssStyleSheet, [core.String]),
[dartx.item]: dart.definiteFunctionType(html$.StyleSheet, [core.int])
@@ -78173,7 +78921,7 @@
}
addAll(other) {
other[dartx.forEach](dart.fn((k, v) => {
- this.set(k, v);
+ this._set(k, v);
}, StringAndStringTovoid$()));
}
containsValue(value) {
@@ -78186,9 +78934,9 @@
}
putIfAbsent(key, ifAbsent) {
if (!dart.test(this[dartx.containsKey](key))) {
- this.set(key, ifAbsent());
+ this._set(key, ifAbsent());
}
- return this.get(key);
+ return this._get(key);
}
clear() {
for (let key of this.keys) {
@@ -78197,7 +78945,7 @@
}
forEach(f) {
for (let key of this.keys) {
- let value = this.get(key);
+ let value = this._get(key);
f(key, value);
}
}
@@ -78205,7 +78953,7 @@
let attributes = this[_element$][_attributes$];
let keys = JSArrayOfString().of([]);
for (let i = 0, len = attributes[dartx.length]; i < dart.notNull(len); i++) {
- let attr = html$._Attr._check(attributes[dartx.get](i));
+ let attr = html$._Attr._check(attributes[dartx._get](i));
if (dart.test(this[_matches](attr))) {
keys[dartx.add](attr[dartx.name]);
}
@@ -78216,7 +78964,7 @@
let attributes = this[_element$][_attributes$];
let values = JSArrayOfString().of([]);
for (let i = 0, len = attributes[dartx.length]; i < dart.notNull(len); i++) {
- let attr = html$._Attr._check(attributes[dartx.get](i));
+ let attr = html$._Attr._check(attributes[dartx._get](i));
if (dart.test(this[_matches](attr))) {
values[dartx.add](attr[dartx.value]);
}
@@ -78266,10 +79014,10 @@
containsKey(key) {
return this[_element$][_hasAttribute](core.String._check(key));
}
- get(key) {
+ _get(key) {
return this[_element$][dartx.getAttribute](core.String._check(key));
}
- set(key, value) {
+ _set(key, value) {
this[_element$][dartx.setAttribute](key, value);
return value;
}
@@ -78290,16 +79038,16 @@
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
- get: dart.definiteFunctionType(core.String, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ _get: dart.definiteFunctionType(core.String, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
remove: dart.definiteFunctionType(core.String, [core.Object]),
[_matches]: dart.definiteFunctionType(core.bool, [html$.Node])
})
});
dart.defineExtensionMembers(html$._ElementAttributeMap, [
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'remove',
'length'
]);
@@ -78312,15 +79060,15 @@
containsKey(key) {
return this[_element$][_hasAttributeNS](this[_namespace], core.String._check(key));
}
- get(key) {
+ _get(key) {
return this[_element$][dartx.getAttributeNS](this[_namespace], core.String._check(key));
}
- set(key, value) {
+ _set(key, value) {
this[_element$][dartx.setAttributeNS](this[_namespace], key, value);
return value;
}
remove(key) {
- let value = this.get(key);
+ let value = this._get(key);
this[_element$][_removeAttributeNS](this[_namespace], core.String._check(key));
return value;
}
@@ -78337,16 +79085,16 @@
getters: () => ({length: dart.definiteFunctionType(core.int, [])}),
methods: () => ({
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
- get: dart.definiteFunctionType(core.String, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ _get: dart.definiteFunctionType(core.String, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
remove: dart.definiteFunctionType(core.String, [core.Object]),
[_matches]: dart.definiteFunctionType(core.bool, [html$.Node])
})
});
dart.defineExtensionMembers(html$._NamespacedAttributeMap, [
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'remove',
'length'
]);
@@ -78360,7 +79108,7 @@
}
addAll(other) {
other[dartx.forEach](dart.fn((k, v) => {
- this.set(k, v);
+ this._set(k, v);
}, StringAndStringTovoid$()));
}
containsValue(value) {
@@ -78369,11 +79117,11 @@
containsKey(key) {
return this[_attributes$][dartx.containsKey](this[_attr](core.String._check(key)));
}
- get(key) {
- return this[_attributes$][dartx.get](this[_attr](core.String._check(key)));
+ _get(key) {
+ return this[_attributes$][dartx._get](this[_attr](core.String._check(key)));
}
- set(key, value) {
- this[_attributes$][dartx.set](this[_attr](key), value);
+ _set(key, value) {
+ this[_attributes$][dartx._set](this[_attr](key), value);
return value;
}
putIfAbsent(key, ifAbsent) {
@@ -78435,9 +79183,9 @@
let segments = hyphenedName[dartx.split]('-');
let start = dart.test(startUppercase) ? 0 : 1;
for (let i = start; i < dart.notNull(segments[dartx.length]); i++) {
- let segment = segments[dartx.get](i);
+ let segment = segments[dartx._get](i);
if (dart.notNull(segment[dartx.length]) > 0) {
- segments[dartx.set](i, dart.str`${segment[dartx.get](0)[dartx.toUpperCase]()}${segment[dartx.substring](1)}`);
+ segments[dartx._set](i, dart.str`${segment[dartx._get](0)[dartx.toUpperCase]()}${segment[dartx.substring](1)}`);
}
}
return segments[dartx.join]('');
@@ -78445,8 +79193,8 @@
[_toHyphenedName](word) {
let sb = new core.StringBuffer();
for (let i = 0; i < dart.notNull(word[dartx.length]); i++) {
- let lower = word[dartx.get](i)[dartx.toLowerCase]();
- if (word[dartx.get](i) != lower && i > 0) sb.write('-');
+ let lower = word[dartx._get](i)[dartx.toLowerCase]();
+ if (word[dartx._get](i) != lower && i > 0) sb.write('-');
sb.write(lower);
}
return sb.toString();
@@ -78467,8 +79215,8 @@
addAll: dart.definiteFunctionType(dart.void, [MapOfString$String()]),
containsValue: dart.definiteFunctionType(core.bool, [core.Object]),
containsKey: dart.definiteFunctionType(core.bool, [core.Object]),
- get: dart.definiteFunctionType(core.String, [core.Object]),
- set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
+ _get: dart.definiteFunctionType(core.String, [core.Object]),
+ _set: dart.definiteFunctionType(dart.void, [core.String, core.String]),
putIfAbsent: dart.definiteFunctionType(core.String, [core.String, VoidToString()]),
remove: dart.definiteFunctionType(core.String, [core.Object]),
clear: dart.definiteFunctionType(dart.void, []),
@@ -78484,8 +79232,8 @@
'addAll',
'containsValue',
'containsKey',
- 'get',
- 'set',
+ '_get',
+ '_set',
'putIfAbsent',
'remove',
'clear',
@@ -80031,7 +80779,7 @@
add(stream) {
StreamOfT()._check(stream);
if (dart.test(this[_subscriptions][dartx.containsKey](stream))) return;
- this[_subscriptions][dartx.set](stream, stream.listen(dart.bind(this[_controller$0], 'add'), {onError: dart.bind(this[_controller$0], 'addError'), onDone: dart.fn(() => this.remove(stream), VoidTovoid$())}));
+ this[_subscriptions][dartx._set](stream, stream.listen(dart.bind(this[_controller$0], 'add'), {onError: dart.bind(this[_controller$0], 'addError'), onDone: dart.fn(() => this.remove(stream), VoidTovoid$())}));
}
remove(stream) {
StreamOfT()._check(stream);
@@ -80115,10 +80863,10 @@
this.uriPolicy = uriPolicy != null ? uriPolicy : html$.UriPolicy.new();
if (dart.test(html$._Html5NodeValidator._attributeValidators[dartx.isEmpty])) {
for (let attr of html$._Html5NodeValidator._standardAttributes) {
- html$._Html5NodeValidator._attributeValidators[dartx.set](attr, html$._Html5NodeValidator._standardAttributeValidator);
+ html$._Html5NodeValidator._attributeValidators[dartx._set](attr, html$._Html5NodeValidator._standardAttributeValidator);
}
for (let attr of html$._Html5NodeValidator._uriAttributes) {
- html$._Html5NodeValidator._attributeValidators[dartx.set](attr, html$._Html5NodeValidator._uriAttributeValidator);
+ html$._Html5NodeValidator._attributeValidators[dartx._set](attr, html$._Html5NodeValidator._uriAttributeValidator);
}
}
}
@@ -80127,9 +80875,9 @@
}
allowsAttribute(element, attributeName, value) {
let tagName = html$.Element._safeTagName(element);
- let validator = html$._Html5NodeValidator._attributeValidators[dartx.get](dart.str`${tagName}::${attributeName}`);
+ let validator = html$._Html5NodeValidator._attributeValidators[dartx._get](dart.str`${tagName}::${attributeName}`);
if (validator == null) {
- validator = html$._Html5NodeValidator._attributeValidators[dartx.get](dart.str`*::${attributeName}`);
+ validator = html$._Html5NodeValidator._attributeValidators[dartx._get](dart.str`*::${attributeName}`);
}
if (validator == null) {
return false;
@@ -80960,7 +81708,7 @@
if (prevEvent[_shadowCharCode] == event[dartx.charCode]) {
return prevEvent.keyCode;
}
- if ((dart.test(event[dartx.shiftKey]) || dart.test(this[_capsLockOn])) && dart.notNull(event[dartx.charCode]) >= dart.notNull("A"[dartx.codeUnits][dartx.get](0)) && dart.notNull(event[dartx.charCode]) <= dart.notNull("Z"[dartx.codeUnits][dartx.get](0)) && dart.notNull(event[dartx.charCode]) + dart.notNull(html$._KeyboardEventHandler._ROMAN_ALPHABET_OFFSET) == prevEvent[_shadowCharCode]) {
+ if ((dart.test(event[dartx.shiftKey]) || dart.test(this[_capsLockOn])) && dart.notNull(event[dartx.charCode]) >= dart.notNull("A"[dartx.codeUnits][dartx._get](0)) && dart.notNull(event[dartx.charCode]) <= dart.notNull("Z"[dartx.codeUnits][dartx._get](0)) && dart.notNull(event[dartx.charCode]) + dart.notNull(html$._KeyboardEventHandler._ROMAN_ALPHABET_OFFSET) == prevEvent[_shadowCharCode]) {
return prevEvent.keyCode;
}
}
@@ -81158,7 +81906,7 @@
}
e[_shadowKeyCode] = this[_determineKeyCodeForKeypress](e);
if (e[_shadowKeyIdentifier] != null && dart.test(html$._KeyboardEventHandler._keyIdentifier[dartx.containsKey](e[_shadowKeyIdentifier]))) {
- e[_shadowKeyCode] = html$._KeyboardEventHandler._keyIdentifier[dartx.get](e[_shadowKeyIdentifier]);
+ e[_shadowKeyCode] = html$._KeyboardEventHandler._keyIdentifier[dartx._get](e[_shadowKeyIdentifier]);
}
e[_shadowAltKey] = this[_keyDownList][dartx.any](dart.fn(element => element.altKey, KeyEventTobool()));
this[_stream$].add(e);
@@ -81213,7 +81961,7 @@
html$._KeyboardEventHandler._keyIdentifier = dart.const(dart.map({Up: html$.KeyCode.UP, Down: html$.KeyCode.DOWN, Left: html$.KeyCode.LEFT, Right: html$.KeyCode.RIGHT, Enter: html$.KeyCode.ENTER, F1: html$.KeyCode.F1, F2: html$.KeyCode.F2, F3: html$.KeyCode.F3, F4: html$.KeyCode.F4, F5: html$.KeyCode.F5, F6: html$.KeyCode.F6, F7: html$.KeyCode.F7, F8: html$.KeyCode.F8, F9: html$.KeyCode.F9, F10: html$.KeyCode.F10, F11: html$.KeyCode.F11, F12: html$.KeyCode.F12, 'U+007F': html$.KeyCode.DELETE, Home: html$.KeyCode.HOME, End: html$.KeyCode.END, PageUp: html$.KeyCode.PAGE_UP, PageDown: html$.KeyCode.PAGE_DOWN, Insert: html$.KeyCode.INSERT}, core.String, core.int));
dart.defineLazy(html$._KeyboardEventHandler, {
get _ROMAN_ALPHABET_OFFSET() {
- return dart.notNull("a"[dartx.codeUnits][dartx.get](0)) - dart.notNull("A"[dartx.codeUnits][dartx.get](0));
+ return dart.notNull("a"[dartx.codeUnits][dartx._get](0)) - dart.notNull("A"[dartx.codeUnits][dartx._get](0));
}
});
html$.KeyboardEventStream = class KeyboardEventStream extends core.Object {
@@ -81431,7 +82179,7 @@
}
allowsElement(element) {
if (dart.test(this.allowTypeExtension)) {
- let isAttr = element[dartx.attributes][dartx.get]('is');
+ let isAttr = element[dartx.attributes][dartx._get]('is');
if (isAttr != null) {
return dart.test(this.allowedElements.contains(isAttr[dartx.toUpperCase]())) && dart.test(this.allowedElements.contains(html$.Element._safeTagName(element)));
}
@@ -81468,7 +82216,7 @@
if (attributeName == 'template' && value == "") {
return true;
}
- if (element[dartx.attributes][dartx.get]('template') == "") {
+ if (element[dartx.attributes][dartx._get]('template') == "") {
return this[_templateAttrs].contains(attributeName);
}
return false;
@@ -81543,12 +82291,12 @@
clear() {
this[_list$][dartx.clear]();
}
- get(index) {
- return html$._downcast(html$.Node, E)(this[_list$][dartx.get](index));
+ _get(index) {
+ return html$._downcast(html$.Node, E)(this[_list$][dartx._get](index));
}
- set(index, value) {
+ _set(index, value) {
E._check(value);
- this[_list$][dartx.set](index, value);
+ this[_list$][dartx._set](index, value);
return value;
}
set length(newLength) {
@@ -81606,8 +82354,8 @@
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
add: dart.definiteFunctionType(dart.void, [E]),
- get: dart.definiteFunctionType(E, [core.int]),
- set: dart.definiteFunctionType(dart.void, [core.int, E]),
+ _get: dart.definiteFunctionType(E, [core.int]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, E]),
sort: dart.definiteFunctionType(dart.void, [], [EAndEToint()]),
insert: dart.definiteFunctionType(dart.void, [core.int, E]),
removeAt: dart.definiteFunctionType(E, [core.int]),
@@ -81620,8 +82368,8 @@
'add',
'remove',
'clear',
- 'get',
- 'set',
+ '_get',
+ '_set',
'sort',
'indexOf',
'lastIndexOf',
@@ -81702,7 +82450,7 @@
moveNext() {
let nextPosition = dart.notNull(this[_position$0]) + 1;
if (nextPosition < dart.notNull(this[_length$2])) {
- this[_current$4] = this[_array][dartx.get](nextPosition);
+ this[_current$4] = this[_array][dartx._get](nextPosition);
this[_position$0] = nextPosition;
return true;
}
@@ -81742,7 +82490,7 @@
moveNext() {
let nextPosition = dart.notNull(this[_position$0]) + 1;
if (nextPosition < dart.notNull(this[_array][dartx.length])) {
- this[_current$4] = this[_array][dartx.get](nextPosition);
+ this[_current$4] = this[_array][dartx._get](nextPosition);
this[_position$0] = nextPosition;
return true;
}
@@ -82327,9 +83075,9 @@
}
let keys = attrs[dartx.keys][dartx.toList]();
for (let i = dart.notNull(attrs[dartx.length]) - 1; i >= 0; --i) {
- let name = keys[dartx.get](i);
- if (!dart.test(this.validator.allowsAttribute(element, core.String._check(dart.dsend(name, 'toLowerCase')), core.String._check(attrs[dartx.get](name))))) {
- html$.window[dartx.console].warn('Removing disallowed attribute ' + dart.str`<${tag} ${name}="${attrs[dartx.get](name)}">`);
+ let name = keys[dartx._get](i);
+ if (!dart.test(this.validator.allowsAttribute(element, core.String._check(dart.dsend(name, 'toLowerCase')), core.String._check(attrs[dartx._get](name))))) {
+ html$.window[dartx.console].warn('Removing disallowed attribute ' + dart.str`<${tag} ${name}="${attrs[dartx._get](name)}">`);
attrs[dartx.remove](name);
}
}
@@ -82396,17 +83144,17 @@
findSlot(value) {
let length = this.values[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (core.identical(this.values[dartx.get](i), value)) return i;
+ if (core.identical(this.values[dartx._get](i), value)) return i;
}
this.values[dartx.add](value);
this.copies[dartx.add](null);
return length;
}
readSlot(i) {
- return this.copies[dartx.get](i);
+ return this.copies[dartx._get](i);
}
writeSlot(i, x) {
- this.copies[dartx.set](i, x);
+ this.copies[dartx._set](i, x);
}
cleanupSlots() {}
walk(e) {
@@ -82451,7 +83199,7 @@
let copy = this.newJsList(length);
this.writeSlot(slot, copy);
for (; i < dart.notNull(length); i++) {
- dart.dsetindex(copy, i, this.walk(e[dartx.get](i)));
+ dart.dsetindex(copy, i, this.walk(e[dartx._get](i)));
}
return copy;
}
@@ -82485,17 +83233,17 @@
findSlot(value) {
let length = this.values[dartx.length];
for (let i = 0; i < dart.notNull(length); i++) {
- if (dart.test(this.identicalInJs(this.values[dartx.get](i), value))) return i;
+ if (dart.test(this.identicalInJs(this.values[dartx._get](i), value))) return i;
}
this.values[dartx.add](value);
this.copies[dartx.add](null);
return length;
}
readSlot(i) {
- return this.copies[dartx.get](i);
+ return this.copies[dartx._get](i);
}
writeSlot(i, x) {
- this.copies[dartx.set](i, x);
+ this.copies[dartx._set](i, x);
}
walk(e) {
if (e == null) return e;
@@ -82628,7 +83376,7 @@
let dict = dart.map();
let keys = Object.getOwnPropertyNames(object);
for (let key of core.Iterable._check(keys)) {
- dict[dartx.set](key, object[key]);
+ dict[dartx._set](key, object[key]);
}
return dict;
};
@@ -82864,8 +83612,8 @@
forEach(f) {
this[_filtered][dartx.forEach](f);
}
- set(index, value) {
- this.get(index)[dartx.replaceWith](value);
+ _set(index, value) {
+ this._get(index)[dartx.replaceWith](value);
return value;
}
set length(newLength) {
@@ -82938,7 +83686,7 @@
}
}
removeAt(index) {
- let result = this.get(index);
+ let result = this._get(index);
result[dartx.remove]();
return result;
}
@@ -82954,7 +83702,7 @@
get length() {
return this[_iterable$0][dartx.length];
}
- get(index) {
+ _get(index) {
return this[_iterable$0][dartx.elementAt](index);
}
get iterator() {
@@ -82983,7 +83731,7 @@
setters: () => ({length: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
forEach: dart.definiteFunctionType(dart.void, [ElementTovoid()]),
- set: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
+ _set: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
add: dart.definiteFunctionType(dart.void, [html$.Element]),
addAll: dart.definiteFunctionType(dart.void, [IterableOfElement()]),
sort: dart.definiteFunctionType(dart.void, [], [ElementAndElementToint()]),
@@ -82994,12 +83742,12 @@
insert: dart.definiteFunctionType(dart.void, [core.int, html$.Element]),
insertAll: dart.definiteFunctionType(dart.void, [core.int, IterableOfElement()]),
removeAt: dart.definiteFunctionType(html$.Element, [core.int]),
- get: dart.definiteFunctionType(html$.Element, [core.int])
+ _get: dart.definiteFunctionType(html$.Element, [core.int])
})
});
dart.defineExtensionMembers(html_common.FilteredElementList, [
'forEach',
- 'set',
+ '_set',
'add',
'addAll',
'contains',
@@ -83014,7 +83762,7 @@
'insertAll',
'removeAt',
'remove',
- 'get',
+ '_get',
'length',
'reversed',
'length',
@@ -83029,7 +83777,7 @@
startIndex = 0;
}
for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dart.notNull(i) + 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -83043,7 +83791,7 @@
startIndex = dart.notNull(a[dartx.length]) - 1;
}
for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
- if (dart.equals(a[dartx.get](i), element)) {
+ if (dart.equals(a[dartx._get](i), element)) {
return i;
}
}
@@ -83054,7 +83802,7 @@
if (dart.notNull(end) < dart.notNull(start)) dart.throw(new core.RangeError.value(end));
if (dart.notNull(end) > dart.notNull(a[dartx.length])) dart.throw(new core.RangeError.value(end));
for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
- accumulator[dartx.add](a[dartx.get](i));
+ accumulator[dartx.add](a[dartx._get](i));
}
return accumulator;
}
@@ -86276,7 +87024,42 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get height() {
+ return this[height$];
+ }
+ set height(value) {
+ super.height = value;
+ }
+ get result() {
+ return this[result];
+ }
+ set result(value) {
+ super.result = value;
+ }
+ get width() {
+ return this[width$];
+ }
+ set width(value) {
+ super.width = value;
+ }
+ get x() {
+ return this[x];
+ }
+ set x(value) {
+ super.x = value;
+ }
+ get y() {
+ return this[y];
+ }
+ set y(value) {
+ super.y = value;
+ }
};
+ const height$ = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'height'.toString());
+ const result = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'result'.toString());
+ const width$ = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'width'.toString());
+ const x = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'x'.toString());
+ const y = Symbol(svg$.FilterPrimitiveStandardAttributes.name + "." + 'y'.toString());
dart.setSignature(svg$.FilterPrimitiveStandardAttributes, {
constructors: () => ({_: dart.definiteFunctionType(svg$.FilterPrimitiveStandardAttributes, [])}),
fields: () => ({
@@ -86302,7 +87085,21 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get preserveAspectRatio() {
+ return this[preserveAspectRatio];
+ }
+ set preserveAspectRatio(value) {
+ super.preserveAspectRatio = value;
+ }
+ get viewBox() {
+ return this[viewBox];
+ }
+ set viewBox(value) {
+ super.viewBox = value;
+ }
};
+ const preserveAspectRatio = Symbol(svg$.FitToViewBox.name + "." + 'preserveAspectRatio'.toString());
+ const viewBox = Symbol(svg$.FitToViewBox.name + "." + 'viewBox'.toString());
dart.setSignature(svg$.FitToViewBox, {
constructors: () => ({_: dart.definiteFunctionType(svg$.FitToViewBox, [])}),
fields: () => ({
@@ -86525,8 +87322,8 @@
const __setter__$ = Symbol('__setter__');
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -86551,11 +87348,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -86584,7 +87381,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -86623,8 +87420,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg$.Length, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Length]),
+ [dartx._get]: dart.definiteFunctionType(svg$.Length, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Length]),
[dartx.elementAt]: dart.definiteFunctionType(svg$.Length, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, svg$.Length]),
[dartx.appendItem]: dart.definiteFunctionType(svg$.Length, [svg$.Length]),
@@ -87131,8 +87928,8 @@
dart.registerExtension(dart.global.SVGNumber, svg$.Number);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -87157,11 +87954,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -87190,7 +87987,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -87229,8 +88026,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg$.Number, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Number]),
+ [dartx._get]: dart.definiteFunctionType(svg$.Number, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Number]),
[dartx.elementAt]: dart.definiteFunctionType(svg$.Number, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, svg$.Number]),
[dartx.appendItem]: dart.definiteFunctionType(svg$.Number, [svg$.Number]),
@@ -88116,8 +88913,8 @@
dart.registerExtension(dart.global.SVGPathSegLinetoVerticalRel, svg$.PathSegLinetoVerticalRel);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -88142,11 +88939,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -88175,7 +88972,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -88214,8 +89011,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg$.PathSeg, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg$.PathSeg]),
+ [dartx._get]: dart.definiteFunctionType(svg$.PathSeg, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg$.PathSeg]),
[dartx.elementAt]: dart.definiteFunctionType(svg$.PathSeg, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, svg$.PathSeg]),
[dartx.appendItem]: dart.definiteFunctionType(svg$.PathSeg, [svg$.PathSeg]),
@@ -88881,8 +89678,8 @@
dart.registerExtension(dart.global.SVGStopElement, svg$.StopElement);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -88907,11 +89704,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -88940,7 +89737,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -88979,8 +89776,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.String, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
+ [dartx._get]: dart.definiteFunctionType(core.String, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
[dartx.elementAt]: dart.definiteFunctionType(core.String, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, core.String]),
[dartx.appendItem]: dart.definiteFunctionType(core.String, [core.String]),
@@ -89055,7 +89852,7 @@
this[_element$0] = element;
}
readClasses() {
- let classname = this[_element$0][dartx.attributes][dartx.get]('class');
+ let classname = this[_element$0][dartx.attributes][dartx._get]('class');
let s = LinkedHashSetOfString().new();
if (classname == null) {
return s;
@@ -89069,7 +89866,7 @@
return s;
}
writeClasses(s) {
- this[_element$0][dartx.attributes][dartx.set]('class', s.join(' '));
+ this[_element$0][dartx.attributes][dartx._set]('class', s.join(' '));
}
};
dart.setSignature(svg$._AttributeClassSet, {
@@ -89124,7 +89921,7 @@
svg$.SvgSvgElement = class SvgSvgElement extends svg$.GraphicsElement {
static new() {
let el = svg$.SvgElement.tag("svg");
- el[dartx.attributes][dartx.set]('version', "1.1");
+ el[dartx.attributes][dartx._set]('version', "1.1");
return svg$.SvgSvgElement._check(el);
}
static _() {
@@ -89549,7 +90346,28 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get requiredExtensions() {
+ return this[requiredExtensions];
+ }
+ set requiredExtensions(value) {
+ super.requiredExtensions = value;
+ }
+ get requiredFeatures() {
+ return this[requiredFeatures];
+ }
+ set requiredFeatures(value) {
+ super.requiredFeatures = value;
+ }
+ get systemLanguage() {
+ return this[systemLanguage];
+ }
+ set systemLanguage(value) {
+ super.systemLanguage = value;
+ }
};
+ const requiredExtensions = Symbol(svg$.Tests.name + "." + 'requiredExtensions'.toString());
+ const requiredFeatures = Symbol(svg$.Tests.name + "." + 'requiredFeatures'.toString());
+ const systemLanguage = Symbol(svg$.Tests.name + "." + 'systemLanguage'.toString());
dart.setSignature(svg$.Tests, {
constructors: () => ({_: dart.definiteFunctionType(svg$.Tests, [])}),
fields: () => ({
@@ -89736,8 +90554,8 @@
dart.registerExtension(dart.global.SVGTransform, svg$.Transform);
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -89764,11 +90582,11 @@
get [dartx.numberOfItems]() {
return this.numberOfItems;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.getItem](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -89797,7 +90615,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[__setter__$](index, newItem) {
return this.__setter__(index, newItem);
@@ -89842,8 +90660,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(svg$.Transform, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Transform]),
+ [dartx._get]: dart.definiteFunctionType(svg$.Transform, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, svg$.Transform]),
[dartx.elementAt]: dart.definiteFunctionType(svg$.Transform, [core.int]),
[__setter__$]: dart.definiteFunctionType(dart.void, [core.int, svg$.Transform]),
[dartx.appendItem]: dart.definiteFunctionType(svg$.Transform, [svg$.Transform]),
@@ -89881,7 +90699,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get href() {
+ return this[href$0];
+ }
+ set href(value) {
+ super.href = value;
+ }
};
+ const href$0 = Symbol(svg$.UriReference.name + "." + 'href'.toString());
dart.setSignature(svg$.UriReference, {
constructors: () => ({_: dart.definiteFunctionType(svg$.UriReference, [])}),
fields: () => ({href: svg$.AnimatedString})
@@ -90063,7 +90888,14 @@
static _() {
dart.throw(new core.UnsupportedError("Not supported"));
}
+ get zoomAndPan() {
+ return this[zoomAndPan];
+ }
+ set zoomAndPan(value) {
+ this[zoomAndPan] = value;
+ }
};
+ const zoomAndPan = Symbol(svg$.ZoomAndPan.name + "." + 'zoomAndPan'.toString());
dart.setSignature(svg$.ZoomAndPan, {
constructors: () => ({_: dart.definiteFunctionType(svg$.ZoomAndPan, [])}),
fields: () => ({zoomAndPan: core.int}),
@@ -93806,8 +94638,8 @@
const _item_1 = Symbol('_item_1');
dart.defineExtensionNames([
'length',
- 'get',
- 'set',
+ '_get',
+ '_set',
'length',
'first',
'last',
@@ -93822,11 +94654,11 @@
get [dartx.length]() {
return this.length;
}
- [dartx.get](index) {
+ [dartx._get](index) {
if (index >>> 0 !== index || index >= this[dartx.length]) dart.throw(core.RangeError.index(index, this));
return this[dartx.item](index);
}
- [dartx.set](index, value) {
+ [dartx._set](index, value) {
dart.throw(new core.UnsupportedError("Cannot assign element of immutable List."));
return value;
}
@@ -93855,7 +94687,7 @@
dart.throw(new core.StateError("More than one element"));
}
[dartx.elementAt](index) {
- return this[dartx.get](index);
+ return this[dartx._get](index);
}
[dartx.item](index) {
return html_common.convertNativeToDart_Dictionary(this[_item_1](index));
@@ -93875,8 +94707,8 @@
}),
setters: () => ({[dartx.length]: dart.definiteFunctionType(dart.void, [core.int])}),
methods: () => ({
- [dartx.get]: dart.definiteFunctionType(core.Map, [core.int]),
- [dartx.set]: dart.definiteFunctionType(dart.void, [core.int, core.Map]),
+ [dartx._get]: dart.definiteFunctionType(core.Map, [core.int]),
+ [dartx._set]: dart.definiteFunctionType(dart.void, [core.int, core.Map]),
[dartx.elementAt]: dart.definiteFunctionType(core.Map, [core.int]),
[dartx.item]: dart.definiteFunctionType(core.Map, [core.int]),
[_item_1]: dart.definiteFunctionType(dart.dynamic, [dart.dynamic])
diff --git a/pkg/dev_compiler/lib/src/analyzer/context.dart b/pkg/dev_compiler/lib/src/analyzer/context.dart
index bc47716..05bacf9 100644
--- a/pkg/dev_compiler/lib/src/analyzer/context.dart
+++ b/pkg/dev_compiler/lib/src/analyzer/context.dart
@@ -139,10 +139,12 @@
{ResourceProvider resourceProvider}) {
resourceProvider ??= PhysicalResourceProvider.INSTANCE;
UriResolver packageResolver() {
- ContextBuilder builder = new ContextBuilder(resourceProvider, null, null);
+ ContextBuilderOptions builderOptions = new ContextBuilderOptions();
if (options.packageRoot != null) {
- builder.defaultPackagesDirectoryPath = options.packageRoot;
+ builderOptions.defaultPackagesDirectoryPath = options.packageRoot;
}
+ ContextBuilder builder = new ContextBuilder(resourceProvider, null, null,
+ options: builderOptions);
return new PackageMapUriResolver(resourceProvider,
builder.convertPackagesToMap(builder.createPackageMap('')));
}
diff --git a/pkg/dev_compiler/lib/src/compiler/code_generator.dart b/pkg/dev_compiler/lib/src/compiler/code_generator.dart
index 221d94c..42a72ca 100644
--- a/pkg/dev_compiler/lib/src/compiler/code_generator.dart
+++ b/pkg/dev_compiler/lib/src/compiler/code_generator.dart
@@ -74,7 +74,7 @@
final _moduleItems = <JS.ModuleItem>[];
/// Table of named and possibly hoisted types.
- final _typeTable = new TypeTable();
+ TypeTable _typeTable;
/// The global extension type table.
final ExtensionTypeSet _extensionTypes;
@@ -97,8 +97,8 @@
final _initializingFormalTemps =
new HashMap<ParameterElement, JS.TemporaryId>();
- final _dartxVar = new JS.Identifier('dartx');
- final _runtimeLibVar = new JS.Identifier('dart');
+ JS.Identifier _extensionSymbolsModule;
+ JS.Identifier _runtimeModule;
final namedArgumentTemp = new JS.TemporaryId('opts');
final _hasDeferredSupertype = new HashSet<ClassElement>();
@@ -217,7 +217,10 @@
true)
.forEach(assembler.addLinkedLibrary);
- return assembler.assemble().toBuffer();
+ var bundle = assembler.assemble();
+ // Preserve only API-level information in the summary.
+ bundle.flushInformative();
+ return bundle.toBuffer();
}
JS.Program _emitModule(List<CompilationUnit> compilationUnits) {
@@ -228,6 +231,18 @@
// Transform the AST to make coercions explicit.
compilationUnits = CoercionReifier.reify(compilationUnits);
+ if (compilationUnits.any((u) => _isDartRuntime(u.element.library))) {
+ // Don't allow these to be renamed when we're building the SDK.
+ // There is JS code in dart:* that depends on their names.
+ _runtimeModule = new JS.Identifier('dart');
+ _extensionSymbolsModule = new JS.Identifier('dartx');
+ } else {
+ // Otherwise allow these to be renamed so users can write them.
+ _runtimeModule = new JS.TemporaryId('dart');
+ _extensionSymbolsModule = new JS.TemporaryId('dartx');
+ }
+ _typeTable = new TypeTable(_runtimeModule);
+
// Initialize our library variables.
var items = <JS.ModuleItem>[];
for (var unit in compilationUnits) {
@@ -235,7 +250,7 @@
if (unit.element != library.definingCompilationUnit) continue;
var libraryTemp = _isDartRuntime(library)
- ? _runtimeLibVar
+ ? _runtimeModule
: new JS.TemporaryId(jsLibraryName(_libraryRoot, library));
_libraries[library] = libraryTemp;
items.add(new JS.ExportDeclaration(
@@ -244,8 +259,8 @@
// 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(
- js.call('const # = Object.create(null)', [_dartxVar])));
+ items.add(new JS.ExportDeclaration(js
+ .call('const # = Object.create(null)', [_extensionSymbolsModule])));
}
}
@@ -329,7 +344,7 @@
var jsName = _getJSName(e);
if (jsName == null) return null;
var fullName = ['global']..addAll(jsName);
- JS.Expression access = _runtimeLibVar;
+ JS.Expression access = _runtimeModule;
for (var part in fullName) {
access = new JS.PropertyAccess(access, js.string(part));
}
@@ -388,8 +403,8 @@
var imports =
libraries.map((l) => new JS.NameSpecifier(_imports[l])).toList();
if (module == coreModuleName) {
- imports.add(new JS.NameSpecifier(_runtimeLibVar));
- imports.add(new JS.NameSpecifier(_dartxVar));
+ imports.add(new JS.NameSpecifier(_runtimeModule));
+ imports.add(new JS.NameSpecifier(_extensionSymbolsModule));
}
items.add(new JS.ImportDeclaration(
namedImports: imports, from: js.string(module, "'")));
@@ -505,8 +520,8 @@
} else {
// top-level fields, getters, setters need to copy the property
// descriptor.
- _moduleItems.add(js.statement('dart.export(#, #, #);',
- [libraryName, name.receiver, name.selector]));
+ _moduleItems.add(_callHelperStatement(
+ 'export(#, #, #);', [libraryName, name.receiver, name.selector]));
}
}
@@ -550,7 +565,7 @@
// Make sure to check when converting to int.
if (from != types.intType && to == types.intType) {
// TODO(jmesserly): fuse this with notNull check.
- return js.call('dart.asInt(#)', jsFrom);
+ return _callHelper('asInt(#)', jsFrom);
}
// A no-op in JavaScript.
@@ -604,7 +619,7 @@
FunctionTypeAliasElement element = node.element;
JS.Expression body = annotate(
- js.call('dart.typedef(#, () => #)', [
+ _callHelper('typedef(#, () => #)', [
js.string(element.name, "'"),
_emitType(element.type, nameType: false, lowerTypedef: true)
]),
@@ -626,7 +641,7 @@
// TODO(jmesserly): if the type fails to resolve, should we generate code
// that throws instead?
assert(options.unsafeForceCompile || options.replCompile);
- return js.call('dart.dynamic');
+ return _callHelper('dynamic');
}
return _emitType(node.type);
}
@@ -738,15 +753,15 @@
var virtualFields = <FieldElement, JS.TemporaryId>{};
var virtualFieldSymbols = <JS.Statement>[];
var staticFieldOverrides = new HashSet<FieldElement>();
+ var extensions = _extensionsToImplement(classElem);
_registerPropertyOverrides(classElem, className, superclasses, allFields,
- virtualFields, virtualFieldSymbols, staticFieldOverrides);
+ virtualFields, virtualFieldSymbols, staticFieldOverrides, extensions);
var classExpr = _emitClassExpression(classElem,
_emitClassMethods(node, ctors, fields, superclasses, virtualFields),
fields: allFields);
var body = <JS.Statement>[];
- var extensions = _extensionsToImplement(classElem);
_initExtensionSymbols(classElem, methods, fields, body);
_emitSuperHelperSymbols(_superHelperSymbols, body);
@@ -760,7 +775,7 @@
_emitClassTypeTests(classElem, className, body);
_defineNamedConstructors(ctors, body, className, isCallable);
- _emitVirtualFieldSymbols(virtualFieldSymbols, body);
+ body.addAll(virtualFieldSymbols);
_emitClassSignature(
methods, allFields, classElem, ctors, extensions, className, body);
_defineExtensionMembers(extensions, className, body);
@@ -791,7 +806,7 @@
classExpr.name, _emitCallableClassConstructor(unnamedCtor));
// Name the constructor function the same as the class.
- return js.call('dart.callableClass(#, #)', [ctor, classExpr]);
+ return _callHelper('callableClass(#, #)', [ctor, classExpr]);
}
/// Emits a constructor that ensures instances of this class are callable as
@@ -822,21 +837,21 @@
body.add(js.statement(
'#.is = function is_Object(o) {'
' if (o instanceof this) return true;'
- ' return dart.is(o, this);'
+ ' return #.is(o, this);'
'}',
- className));
+ [className, _runtimeModule]));
body.add(js.statement(
'#.as = function as_Object(o) {'
' if (o == null || o instanceof this) return o;'
- ' return dart.as(o, this);'
+ ' return #.as(o, this);'
'}',
- className));
+ [className, _runtimeModule]));
body.add(js.statement(
'#._check = function check_Object(o) {'
' if (o == null || o instanceof this) return o;'
- ' return dart.check(o, this);'
+ ' return #.check(o, this);'
'}',
- className));
+ [className, _runtimeModule]));
return;
}
if (classElem == stringClass) {
@@ -846,15 +861,15 @@
body.add(js.statement(
'#.as = function as_String(o) {'
' if (typeof o == "string" || o == null) return o;'
- ' return dart.as(o, #);'
+ ' return #.as(o, #);'
'}',
- [className, className]));
+ [className, _runtimeModule, className]));
body.add(js.statement(
'#._check = function check_String(o) {'
' if (typeof o == "string" || o == null) return o;'
- ' return dart.check(o, #);'
+ ' return #.check(o, #);'
'}',
- [className, className]));
+ [className, _runtimeModule, className]));
return;
}
if (classElem == intClass) {
@@ -867,16 +882,16 @@
'#.as = function as_int(o) {'
' if ((typeof o == "number" && Math.floor(o) == o) || o == null)'
' return o;'
- ' return dart.as(o, #);'
+ ' return #.as(o, #);'
'}',
- [className, className]));
+ [className, _runtimeModule, className]));
body.add(js.statement(
'#._check = function check_int(o) {'
' if ((typeof o == "number" && Math.floor(o) == o) || o == null)'
' return o;'
- ' return dart.check(o, #);'
+ ' return #.check(o, #);'
'}',
- [className, className]));
+ [className, _runtimeModule, className]));
return;
}
if (classElem == nullClass) {
@@ -885,15 +900,15 @@
body.add(js.statement(
'#.as = function as_Null(o) {'
' if (o == null) return o;'
- ' return dart.as(o, #);'
+ ' return #.as(o, #);'
'}',
- [className, className]));
+ [className, _runtimeModule, className]));
body.add(js.statement(
'#._check = function check_Null(o) {'
' if (o == null) return o;'
- ' return dart.check(o, #);'
+ ' return #.check(o, #);'
'}',
- [className, className]));
+ [className, _runtimeModule, className]));
return;
}
if (classElem == numClass) {
@@ -903,15 +918,15 @@
body.add(js.statement(
'#.as = function as_num(o) {'
' if (typeof o == "number" || o == null) return o;'
- ' return dart.as(o, #);'
+ ' return #.as(o, #);'
'}',
- [className, className]));
+ [className, _runtimeModule, className]));
body.add(js.statement(
'#._check = function check_num(o) {'
' if (typeof o == "number" || o == null) return o;'
- ' return dart.check(o, #);'
+ ' return #.check(o, #);'
'}',
- [className, className]));
+ [className, _runtimeModule, className]));
return;
}
if (classElem == boolClass) {
@@ -921,15 +936,15 @@
body.add(js.statement(
'#.as = function as_bool(o) {'
' if (o === true || o === false || o == null) return o;'
- ' return dart.as(o, #);'
+ ' return #.as(o, #);'
'}',
- [className, className]));
+ [className, _runtimeModule, className]));
body.add(js.statement(
'#._check = function check_bool(o) {'
' if (o === true || o === false || o == null) return o;'
- ' return dart.check(o, #);'
+ ' return #.check(o, #);'
'}',
- [className, className]));
+ [className, _runtimeModule, className]));
return;
}
// TODO(sra): Add special cases for hot tests like `x is html.Element`.
@@ -942,7 +957,7 @@
// Place non-instanceof version of checks on Interceptor. All
// interceptor classes will inherit the methods via ES6 class static
// inheritance.
- body.add(js.statement('dart.addTypeTests(#);', className));
+ body.add(_callHelperStatement('addTypeTests(#);', className));
// TODO(sra): We could place on the extension type a pointer to the
// peer constructor and use that for the `instanceof` check, e.g.
@@ -980,9 +995,9 @@
if (thisIsSimple == superIsSimple) return;
if (thisIsSimple) {
- body.add(js.statement('dart.addSimpleTypeTests(#);', className));
+ body.add(_callHelperStatement('addSimpleTypeTests(#);', className));
} else {
- body.add(js.statement('dart.addTypeTests(#);', className));
+ body.add(_callHelperStatement('addTypeTests(#);', className));
}
}
@@ -1001,22 +1016,25 @@
List<FieldDeclaration> fields,
Map<FieldElement, JS.TemporaryId> virtualFields,
List<JS.Statement> virtualFieldSymbols,
- Set<FieldElement> staticFieldOverrides) {
+ Set<FieldElement> staticFieldOverrides,
+ Iterable<ExecutableElement> extensionMembers) {
+ var extensionNames =
+ new HashSet<String>.from(extensionMembers.map((e) => e.name));
for (var field in fields) {
- for (VariableDeclaration field in field.fields.variables) {
- var overrideInfo =
- checkForPropertyOverride(field.element, superclasses);
- if (overrideInfo.foundGetter || overrideInfo.foundSetter) {
- if (field.element.isStatic) {
- staticFieldOverrides.add(field.element);
+ for (VariableDeclaration fieldDecl in field.fields.variables) {
+ var field = fieldDecl.element as FieldElement;
+ var overrideInfo = checkForPropertyOverride(field, superclasses);
+ if (overrideInfo.foundGetter ||
+ overrideInfo.foundSetter ||
+ extensionNames.contains(field.name)) {
+ if (field.isStatic) {
+ staticFieldOverrides.add(field);
} else {
- var fieldName =
- _emitMemberName(field.element.name, type: classElem.type);
- var virtualField = new JS.TemporaryId(field.element.name);
- virtualFields[field.element] = virtualField;
+ var virtualField = new JS.TemporaryId(field.name);
+ virtualFields[field] = virtualField;
virtualFieldSymbols.add(js.statement(
'const # = Symbol(#.name + "." + #.toString());',
- [virtualField, className, fieldName]));
+ [virtualField, className, _declareMemberName(field.getter)]));
}
}
}
@@ -1042,11 +1060,6 @@
}
}
- void _emitVirtualFieldSymbols(
- List<JS.Statement> virtualFields, List<JS.Statement> body) {
- body.addAll(virtualFields);
- }
-
List<JS.Identifier> _emitTypeFormals(List<TypeParameterElement> typeFormals) {
return typeFormals
.map((t) => new JS.Identifier(t.name))
@@ -1102,8 +1115,8 @@
// Create static fields for each enum value
for (var i = 0; i < fields.length; ++i) {
- result.add(js.statement('#.# = dart.const(new #(#));',
- [id, fields[i].name, id, js.number(i)]));
+ result.add(js.statement('#.# = #.const(new #(#));',
+ [id, fields[i].name, _runtimeModule, id, js.number(i)]));
}
// Create static values list
@@ -1113,8 +1126,8 @@
// dart.constList helper internally depends on _interceptors.JSArray.
_declareBeforeUse(_jsArray);
- result.add(js.statement(
- '#.values = dart.constList(#, #);', [id, values, _emitType(type)]));
+ result.add(js.statement('#.values = #.constList(#, #);',
+ [id, _runtimeModule, values, _emitType(type)]));
return _statement(result);
}
@@ -1123,7 +1136,7 @@
JS.Statement _defineClassTypeArguments(TypeDefiningElement element,
List<TypeParameterElement> formals, JS.Statement body) {
assert(formals.isNotEmpty);
- var genericCall = js.call('dart.generic((#) => { #; #; return #; })', [
+ var genericCall = _callHelper('generic((#) => { #; #; return #; })', [
_emitTypeFormals(formals),
_typeTable.discharge(formals),
body,
@@ -1131,7 +1144,7 @@
]);
if (element.library.isDartAsync &&
(element.name == "Future" || element.name == "_Future")) {
- genericCall = js.call('dart.flattenFutures(#)', [genericCall]);
+ genericCall = _callHelper('flattenFutures(#)', [genericCall]);
}
var genericDef = js.statement(
'# = #;', [_emitTopLevelName(element, suffix: r'$'), genericCall]);
@@ -1189,7 +1202,7 @@
var mixins =
type.mixins.map((t) => _emitType(t, nameType: false)).toList();
mixins.insert(0, heritage);
- heritage = js.call('dart.mixin(#)', [mixins]);
+ heritage = _callHelper('mixin(#)', [mixins]);
}
_loader.finishTopLevel(element);
@@ -1214,7 +1227,7 @@
// Generate getter
var fn = new JS.Fun([], js.statement('{ return this.#; }', [name]));
var method =
- new JS.Method(_elementMemberName(field.getter), fn, isGetter: true);
+ new JS.Method(_declareMemberName(field.getter), fn, isGetter: true);
jsMethods.add(method);
// Generate setter
@@ -1222,7 +1235,7 @@
var value = new JS.TemporaryId('value');
fn = new JS.Fun(
[value], js.statement('{ this.# = #; }', [name, value]));
- method = new JS.Method(_elementMemberName(field.setter), fn,
+ method = new JS.Method(_declareMemberName(field.setter), fn,
isSetter: true);
jsMethods.add(method);
}
@@ -1409,8 +1422,7 @@
JS.Expression positionalArgs;
if (method.type.namedParameterTypes.isNotEmpty) {
- addProperty(
- 'namedArguments', js.call('dart.extractNamedArgs(#)', [args]));
+ addProperty('namedArguments', _callHelper('extractNamedArgs(#)', [args]));
}
if (method is MethodElement) {
@@ -1432,9 +1444,9 @@
}
}
- var fnBody =
- js.call('this.noSuchMethod(new dart.InvocationImpl(#, #, #))', [
- _elementMemberName(method),
+ var fnBody = js.call('this.noSuchMethod(new #.InvocationImpl(#, #, #))', [
+ _runtimeModule,
+ _declareMemberName(method),
positionalArgs,
new JS.ObjectInitializer(invocationProps)
]);
@@ -1449,7 +1461,7 @@
// TODO(jmesserly): generic type arguments will get dropped.
// We have a similar issue with `dgsend` helpers.
return new JS.Method(
- _elementMemberName(method,
+ _declareMemberName(method,
useExtension:
_extensionTypes.isNativeClass(method.enclosingElement)),
_makeGenericFunction(fn),
@@ -1482,8 +1494,7 @@
Map<FieldElement, JS.TemporaryId> virtualFields) {
var virtualField = virtualFields[field.element];
var result = <JS.Method>[];
- var name = _emitMemberName(field.element.name,
- type: (field.element.enclosingElement as ClassElement).type);
+ var name = _declareMemberName((field.element as FieldElement).getter);
var getter = js.call('function() { return this[#]; }', [virtualField]);
result.add(new JS.Method(name, getter, isGetter: true));
@@ -1512,8 +1523,7 @@
checkForPropertyOverride(methodElement.variable, superclasses);
// Generate a corresponding virtual getter / setter.
- var name = _elementMemberName(methodElement,
- useExtension: _extensionTypes.isNativeClass(type.element));
+ var name = _declareMemberName(methodElement);
if (method.isGetter) {
// Generate a setter
if (field.setter != null || !propertyOverrideResult.foundSetter)
@@ -1553,8 +1563,8 @@
// an ES6 iterator.
return new JS.Method(
js.call('Symbol.iterator'),
- js.call('function() { return new dart.JsIterator(this.#); }',
- [_emitMemberName('iterator', type: t)]) as JS.Fun);
+ js.call('function() { return new #.JsIterator(this.#); }',
+ [_runtimeModule, _emitMemberName('iterator', type: t)]) as JS.Fun);
}
JS.Expression _instantiateAnnotation(Annotation node) {
@@ -1591,8 +1601,11 @@
void _registerExtensionType(
ClassElement classElem, String jsPeerName, List<JS.Statement> body) {
if (jsPeerName != null) {
- body.add(js.statement('dart.registerExtension(dart.global.#, #);',
- [_propertyName(jsPeerName), _emitTopLevelName(classElem)]));
+ body.add(_callHelperStatement('registerExtension(#.global.#, #);', [
+ _runtimeModule,
+ _propertyName(jsPeerName),
+ _emitTopLevelName(classElem)
+ ]));
}
}
@@ -1601,23 +1614,23 @@
if (jsPeerNames.isNotEmpty && classElem.typeParameters.isNotEmpty) {
for (var peer in jsPeerNames) {
// TODO(jmesserly): we should just extend Array in the first place
- var newBaseClass = js.call('dart.global.#', [peer]);
- body.add(js.statement(
- 'dart.setExtensionBaseClass(#, #);', [className, newBaseClass]));
+ var newBaseClass = _callHelper('global.#', [peer]);
+ body.add(_callHelperStatement(
+ 'setExtensionBaseClass(#, #);', [className, newBaseClass]));
}
} else if (_hasDeferredSupertype.contains(classElem)) {
var newBaseClass = _emitType(classElem.type.superclass,
nameType: false, subClass: classElem, className: className);
- body.add(
- js.statement('dart.setBaseClass(#, #);', [className, newBaseClass]));
+ body.add(_callHelperStatement(
+ 'setBaseClass(#, #);', [className, newBaseClass]));
}
}
void _defineNamedConstructors(List<ConstructorDeclaration> ctors,
List<JS.Statement> body, JS.Expression className, bool isCallable) {
var code = isCallable
- ? 'dart.defineNamedConstructorCallable(#, #, #);'
- : 'dart.defineNamedConstructor(#, #)';
+ ? 'defineNamedConstructorCallable(#, #, #);'
+ : 'defineNamedConstructor(#, #)';
for (ConstructorDeclaration member in ctors) {
if (member.name != null && member.factoryKeyword == null) {
@@ -1626,7 +1639,7 @@
args.add(_emitCallableClassConstructor(member.element));
}
- body.add(js.statement(code, args));
+ body.add(_callHelperStatement(code, args));
}
}
}
@@ -1659,8 +1672,9 @@
List<JS.Statement> body) {
// Metadata
if (options.emitMetadata && metadata.isNotEmpty) {
- body.add(js.statement('#[dart.metadata] = () => #;', [
+ body.add(js.statement('#[#.metadata] = () => #;', [
className,
+ _runtimeModule,
new JS.ArrayInitializer(
new List<JS.Expression>.from(metadata.map(_instantiateAnnotation)))
]));
@@ -1676,9 +1690,9 @@
if (extensions.isNotEmpty) {
var methodNames = <JS.Expression>[];
for (var e in extensions) {
- methodNames.add(_elementMemberName(e, useExtension: false));
+ methodNames.add(_declareMemberName(e, useExtension: false));
}
- body.add(js.statement('dart.defineExtensionMembers(#, #);', [
+ body.add(_callHelperStatement('defineExtensionMembers(#, #);', [
className,
new JS.ArrayInitializer(methodNames, multiline: methodNames.length > 4)
]));
@@ -1695,8 +1709,9 @@
JS.Expression className,
List<JS.Statement> body) {
if (classElem.interfaces.isNotEmpty) {
- body.add(js.statement('#[dart.implements] = () => #;', [
+ body.add(js.statement('#[#.implements] = () => #;', [
className,
+ _runtimeModule,
new JS.ArrayInitializer(
new List<JS.Expression>.from(classElem.interfaces.map(_emitType)))
]));
@@ -1742,8 +1757,7 @@
if (inheritedElement != null && inheritedElement.type == element.type) {
continue;
}
- var memberName = _elementMemberName(element,
- useExtension: _extensionTypes.isNativeClass(classElem));
+ var memberName = _declareMemberName(element);
var property = new JS.Property(memberName, type);
tMember.add(property);
// TODO(vsm): Why do we need this?
@@ -1757,8 +1771,7 @@
for (FieldDeclaration node in fields) {
for (VariableDeclaration field in node.fields.variables) {
var element = field.element as FieldElement;
- var memberName = _elementMemberName(element.getter,
- useExtension: _extensionTypes.isNativeClass(classElem));
+ var memberName = _declareMemberName(element.getter);
var type = _emitAnnotatedType(element.type, node.metadata);
var property = new JS.Property(memberName, type);
(node.isStatic ? tStaticFields : tInstanceFields).add(property);
@@ -1821,12 +1834,12 @@
}
if (!sigFields.isEmpty || extensions.isNotEmpty) {
var sig = new JS.ObjectInitializer(sigFields);
- body.add(js.statement('dart.setSignature(#, #);', [className, sig]));
+ body.add(_callHelperStatement('setSignature(#, #);', [className, sig]));
}
// Add static property dart._runtimeType to Object.
// All other Dart classes will (statically) inherit this property.
if (classElem == objectClass) {
- body.add(js.statement('dart.tagComputed(#, () => #.#);',
+ body.add(_callHelperStatement('tagComputed(#, () => #.#);',
[className, emitLibraryName(dartCoreLibrary), 'Type']));
}
}
@@ -1841,7 +1854,7 @@
var dartxNames = <JS.Expression>[];
for (var m in methods) {
if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
- dartxNames.add(_elementMemberName(m.element, useExtension: false));
+ dartxNames.add(_declareMemberName(m.element, useExtension: false));
}
}
for (var fieldDecl in fields) {
@@ -1849,13 +1862,13 @@
for (var field in fieldDecl.fields.variables) {
var e = field.element as FieldElement;
if (e.isPublic) {
- dartxNames.add(_elementMemberName(e.getter, useExtension: false));
+ dartxNames.add(_declareMemberName(e.getter, useExtension: false));
}
}
}
}
if (dartxNames.isNotEmpty) {
- body.add(js.statement('dart.defineExtensionNames(#)',
+ body.add(_callHelperStatement('defineExtensionNames(#)',
[new JS.ArrayInitializer(dartxNames, multiline: true)]));
}
}
@@ -2153,13 +2166,8 @@
var body = <JS.Statement>[];
fields.forEach((FieldElement e, JS.Expression initialValue) {
- if (virtualFields.containsKey(e)) {
- body.add(
- js.statement('this[#] = #;', [virtualFields[e], initialValue]));
- } else {
- var access = _emitMemberName(e.name, type: e.enclosingElement.type);
- body.add(js.statement('this.# = #;', [access, initialValue]));
- }
+ JS.Expression access = virtualFields[e] ?? _declareMemberName(e.getter);
+ body.add(js.statement('this.# = #;', [access, initialValue]));
});
if (isConst) _loader.finishTopLevel(cls.element);
@@ -2297,10 +2305,7 @@
}
return annotate(
- new JS.Method(
- _elementMemberName(node.element,
- useExtension: _extensionTypes.isNativeClass(type.element)),
- fn,
+ new JS.Method(_declareMemberName(node.element), fn,
isGetter: node.isGetter,
isSetter: node.isSetter,
isStatic: node.isStatic),
@@ -2343,7 +2348,7 @@
props.add(_loader.emitDeclaration(
setter, (node) => _emitTopLevelProperty(node)));
}
- return js.statement('dart.copyProperties(#, { # });',
+ return _callHelperStatement('copyProperties(#, { # });',
[emitLibraryName(currentLibrary), props]);
}
if (node.isSetter) {
@@ -2354,7 +2359,7 @@
props.add(_loader.emitDeclaration(
getter, (node) => _emitTopLevelProperty(node)));
}
- return js.statement('dart.copyProperties(#, { # });',
+ return _callHelperStatement('copyProperties(#, { # });',
[emitLibraryName(currentLibrary), props]);
}
@@ -2453,9 +2458,9 @@
var lazy = topLevel && !_typeIsLoaded(type);
var typeRep = _emitFunctionType(type, definite: true);
if (lazy) {
- return js.call('dart.lazyFn(#, () => #)', [fn, typeRep]);
+ return _callHelper('lazyFn(#, () => #)', [fn, typeRep]);
} else {
- return js.call('dart.fn(#, #)', [fn, typeRep]);
+ return _callHelper('fn(#, #)', [fn, typeRep]);
}
}
@@ -2607,7 +2612,7 @@
}
var T = _emitType(returnType);
- return js.call('dart.#(#)', [
+ return _callHelper('#(#)', [
kind,
[gen, T]..addAll(visitFormalParameterList(parameters, destructure: false))
]);
@@ -2647,7 +2652,7 @@
if (typeArgs == null) {
return simpleId;
}
- return js.call('dart.gbind(#, #)', [simpleId, typeArgs]);
+ return _callHelper('gbind(#, #)', [simpleId, typeArgs]);
}
/// Emits a simple identifier, handling implicit `this` as well as
@@ -2674,7 +2679,7 @@
// If the type is a type literal expression in Dart code, wrap the raw
// runtime type in a "Type" instance.
if (!_isInForeignJS && _isTypeLiteral(node)) {
- typeName = js.call('dart.wrapType(#)', typeName);
+ typeName = _callHelper('wrapType(#)', typeName);
}
return typeName;
@@ -2705,8 +2710,8 @@
// For instance members, we add implicit-this.
// For method tear-offs, we ensure it's a bound method.
var tearOff = element is MethodElement && !inInvocationContext(node);
- var code = (tearOff) ? 'dart.bind(this, #)' : 'this.#';
- return js.call(code, member);
+ if (tearOff) return _callHelper('bind(this, #)', member);
+ return js.call('this.#', member);
}
if (element is ParameterElement) {
@@ -2823,7 +2828,7 @@
nameType: nameType,
hoistType: hoistType);
var helper = (definite) ? 'definiteFunctionType' : 'functionType';
- var fullType = js.call('dart.${helper}(#)', [parts]);
+ var fullType = _callHelper('${helper}(#)', [parts]);
if (!nameType) return fullType;
return _typeTable.nameType(type, fullType,
hoistType: hoistType, definite: definite);
@@ -2919,11 +2924,11 @@
JS.Expression className}) {
// The void and dynamic types are not defined in core.
if (type.isVoid) {
- return js.call('dart.void');
+ return _callHelper('void');
} else if (type.isDynamic) {
- return js.call('dart.dynamic');
+ return _callHelper('dynamic');
} else if (type.isBottom) {
- return js.call('dart.bottom');
+ return _callHelper('bottom');
}
_declareBeforeUse(type.element);
@@ -3070,11 +3075,18 @@
var l = _visit(_bindValue(vars, 'l', target));
var name = _emitMemberName(id.name);
return new JS.MetaLet(vars, [
- js.call('(#[(#[dart._extensionType]) ? dartx[#] : #] = #)',
- [l, l, name, name, _visit(rhs)])
+ js.call('(#[(#[#._extensionType]) ? #[#] : #] = #)', [
+ l,
+ l,
+ _runtimeModule,
+ name,
+ _extensionSymbolsModule,
+ name,
+ _visit(rhs)
+ ])
]);
}
- return js.call('dart.#(#, #, #)', [
+ return _callHelper('#(#, #, #)', [
_emitDynamicOperationName('dput'),
_visit(target),
_emitMemberName(id.name),
@@ -3107,7 +3119,7 @@
// TODO(sra): We should get here only for compiler bugs or weirdness due to
// --unsafe-force-compile. Once those paths have been addressed, throw at
// compile time.
- return js.call('dart.throwUnimplementedError((#, #, #))',
+ return _callHelper('throwUnimplementedError((#, #, #))',
[js.string('$lhs ='), _visit(rhs), js.string(problem)]);
}
@@ -3357,14 +3369,21 @@
var vars = <JS.MetaLetVariable, JS.Expression>{};
var l = _visit(_bindValue(vars, 'l', target));
jsTarget = new JS.MetaLet(vars, [
- js.call('(#[(#[dart._extensionType]) ? dartx[#] : #]).bind(#)',
- [l, l, memberName, memberName, l])
+ js.call('(#[(#[#._extensionType]) ? #[#] : #]).bind(#)', [
+ l,
+ l,
+ _runtimeModule,
+ memberName,
+ _extensionSymbolsModule,
+ memberName,
+ l
+ ])
]);
if (typeArgs != null) jsTarget = new JS.Call(jsTarget, typeArgs);
return new JS.Call(jsTarget, args);
}
if (typeArgs != null) {
- return js.call('dart.#(#, #, #, #)', [
+ return _callHelper('#(#, #, #, #)', [
_emitDynamicOperationName('dgsend'),
jsTarget,
new JS.ArrayInitializer(typeArgs),
@@ -3372,13 +3391,13 @@
args
]);
} else {
- return js.call('dart.#(#, #, #)',
+ return _callHelper('#(#, #, #)',
[_emitDynamicOperationName('dsend'), jsTarget, memberName, args]);
}
}
if (_isObjectMemberCall(target, name)) {
assert(typeArgs == null); // Object methods don't take type args.
- return js.call('dart.#(#, #)', [name, jsTarget, args]);
+ return _callHelper('#(#, #)', [name, jsTarget, args]);
}
jsTarget = new JS.PropertyAccess(jsTarget, memberName);
@@ -3391,13 +3410,13 @@
InvocationExpression node, JS.Expression fn, List<JS.Expression> args) {
var typeArgs = _emitInvokeTypeArguments(node);
if (typeArgs != null) {
- return js.call('dart.dgcall(#, #, #)',
- [fn, new JS.ArrayInitializer(typeArgs), args]);
+ return _callHelper(
+ 'dgcall(#, #, #)', [fn, new JS.ArrayInitializer(typeArgs), args]);
} else {
if (_inWhitelistCode(node, isCall: true)) {
return new JS.Call(fn, args);
}
- return js.call('dart.dcall(#, #)', [fn, args]);
+ return _callHelper('dcall(#, #)', [fn, args]);
}
}
@@ -3640,7 +3659,7 @@
@override
JS.Statement visitAssertStatement(AssertStatement node) =>
// TODO(jmesserly): only emit in checked mode.
- js.statement('dart.assert(#);', _visit(node.condition));
+ _callHelperStatement('assert(#);', _visit(node.condition));
@override
JS.Statement visitReturnStatement(ReturnStatement node) {
@@ -3850,7 +3869,7 @@
objExpr = emitLibraryName(target);
}
- return js.statement('dart.defineLazy(#, { # });', [objExpr, methods]);
+ return _callHelperStatement('defineLazy(#, { # });', [objExpr, methods]);
}
PropertyAccessorElement _findAccessor(VariableElement element,
@@ -3967,7 +3986,7 @@
if (expr == null) return null;
var jsExpr = _visit(expr);
if (!isNullable(expr)) return jsExpr;
- return js.call('dart.notNull(#)', jsExpr);
+ return _callHelper('notNull(#)', jsExpr);
}
@override
@@ -3997,7 +4016,8 @@
return _emitSend(left, op.lexeme, [right]);
} else {
var bang = op.type == TokenType.BANG_EQ ? '!' : '';
- code = '${bang}dart.equals(#, #)';
+ code = '${bang}#.equals(#, #)';
+ return js.call(code, [_runtimeModule, _visit(left), _visit(right)]);
}
return js.call(code, [_visit(left), _visit(right)]);
}
@@ -4310,7 +4330,7 @@
}
JS.Expression _emitConst(JS.Expression expr()) =>
- _cacheConst(() => js.call('dart.const(#)', expr()));
+ _cacheConst(() => _callHelper('const(#)', expr()));
/// Returns a new expression, which can be be used safely *once* on the
/// left hand side, and *once* on the right side of an assignment.
@@ -4481,7 +4501,10 @@
context: expr);
}
- return _emitSend(expr, op.lexeme[0], []);
+ var operatorName = op.lexeme;
+ // Use the name from the Dart spec.
+ if (operatorName == '-') operatorName = 'unary-';
+ return _emitSend(expr, operatorName, []);
}
// Cascades can contain [IndexExpression], [MethodInvocation] and
@@ -4569,8 +4592,8 @@
}
}
if (tail.isEmpty) return _visit(node);
- return js.call(
- 'dart.nullSafe(#, #)', [_visit(node) as JS.Expression, tail.reversed]);
+ return _callHelper(
+ 'nullSafe(#, #)', [_visit(node) as JS.Expression, tail.reversed]);
}
static Token _getOperator(Expression node) {
@@ -4667,11 +4690,11 @@
var vars = <JS.MetaLetVariable, JS.Expression>{};
var l = _visit(_bindValue(vars, 'l', target));
return new JS.MetaLet(vars, [
- js.call('(#[dart._extensionType]) ? #[dartx[#]] : #.#',
- [l, l, name, l, name])
+ js.call('(#[#._extensionType]) ? #[#[#]] : #.#',
+ [l, _runtimeModule, l, _extensionSymbolsModule, name, l, name])
]);
}
- return js.call('dart.#(#, #)',
+ return _callHelper('#(#, #)',
[_emitDynamicOperationName('dload'), _visit(target), name]);
}
@@ -4688,22 +4711,22 @@
if (member != null && member is MethodElement && !isStatic) {
// Tear-off methods: explicitly bind it.
if (isSuper) {
- result = js.call('dart.bind(this, #, #.#)', [name, jsTarget, name]);
+ result = _callHelper('bind(this, #, #.#)', [name, jsTarget, name]);
} else if (_isObjectMemberCall(target, memberName)) {
- result = js.call('dart.bind(#, #, dart.#)',
- [jsTarget, _propertyName(memberName), memberName]);
+ result = _callHelper('bind(#, #, #.#)',
+ [jsTarget, _propertyName(memberName), _runtimeModule, memberName]);
} else {
- result = js.call('dart.bind(#, #)', [jsTarget, name]);
+ result = _callHelper('bind(#, #)', [jsTarget, name]);
}
} else if (_isObjectMemberCall(target, memberName)) {
- result = js.call('dart.#(#)', [memberName, jsTarget]);
+ result = _callHelper('#(#)', [memberName, jsTarget]);
} else {
result = js.call('#.#', [jsTarget, name]);
}
if (typeArgs == null) {
return result;
}
- return js.call('dart.gbind(#, #)', [result, typeArgs]);
+ return _callHelper('gbind(#, #)', [result, typeArgs]);
}
/// Emits a generic send, like an operator method.
@@ -4714,24 +4737,32 @@
JS.Expression _emitSend(
Expression target, String name, List<Expression> args) {
var type = getStaticType(target);
- var memberName = _emitMemberName(name, unary: args.isEmpty, type: type);
+ var memberName = _emitMemberName(name, type: type);
if (isDynamicInvoke(target)) {
if (_inWhitelistCode(target)) {
var vars = <JS.MetaLetVariable, JS.Expression>{};
var l = _visit(_bindValue(vars, 'l', target));
return new JS.MetaLet(vars, [
- js.call('(#[(#[dart._extensionType]) ? dartx[#] : #]).call(#, #)',
- [l, l, memberName, memberName, l, _visitList(args)])
+ js.call('(#[(#[#._extensionType]) ? #[#] : #]).call(#, #)', [
+ l,
+ l,
+ _runtimeModule,
+ memberName,
+ _extensionSymbolsModule,
+ memberName,
+ l,
+ _visitList(args)
+ ])
]);
}
// dynamic dispatch
var dynamicHelper = const {'[]': 'dindex', '[]=': 'dsetindex'}[name];
if (dynamicHelper != null) {
- return js.call('dart.$dynamicHelper(#, #)',
+ return _callHelper('$dynamicHelper(#, #)',
[_visit(target) as JS.Expression, _visitList(args)]);
} else {
- return js.call('dart.dsend(#, #, #)',
- [_visit(target), memberName, _visitList(args)]);
+ return _callHelper(
+ 'dsend(#, #, #)', [_visit(target), memberName, _visitList(args)]);
}
}
@@ -4775,9 +4806,9 @@
visitThrowExpression(ThrowExpression node) {
var expr = _visit(node.expression);
if (node.parent is ExpressionStatement) {
- return js.statement('dart.throw(#);', expr);
+ return _callHelperStatement('throw(#);', expr);
} else {
- return js.call('dart.throw(#)', expr);
+ return _callHelper('throw(#)', expr);
}
}
@@ -4980,8 +5011,8 @@
}
if (node.stackTraceParameter != null) {
var stackVar = node.stackTraceParameter.name;
- body.add(js.statement(
- 'let # = dart.stackTrace(#);', [stackVar, _visit(name)]));
+ body.add(js.statement('let # = #.stackTrace(#);',
+ [stackVar, _runtimeModule, _visit(name)]));
}
}
@@ -5063,7 +5094,7 @@
_declareBeforeUse(_jsArray);
if (isConst) {
var typeRep = _emitType(elementType);
- list = js.call('dart.constList(#, #)', [list, typeRep]);
+ list = _callHelper('constList(#, #)', [list, typeRep]);
} else {
// Call `new JSArray<E>.of(list)`
var jsArrayType = _jsArray.type.instantiate(type.typeArguments);
@@ -5109,7 +5140,7 @@
if (reifyTypeArgs) {
types.addAll(typeArgs.map((e) => _emitType(e)));
}
- return js.call('dart.map(#, #)', [mapArguments, types]);
+ return _callHelper('map(#, #)', [mapArguments, types]);
}
if (node.constKeyword != null) return _emitConst(emitMap);
@@ -5127,7 +5158,7 @@
@override
JS.Expression visitStringInterpolation(StringInterpolation node) {
return new JS.TaggedTemplate(
- js.call('dart.str'), new JS.TemplateString(_visitList(node.elements)));
+ _callHelper('str'), new JS.TemplateString(_visitList(node.elements)));
}
@override
@@ -5149,7 +5180,7 @@
_unimplementedCall('Unimplemented ${node.runtimeType}: $node');
JS.Expression _unimplementedCall(String comment) {
- return js.call('dart.throw(#)', [js.escapedString(comment)]);
+ return _callHelper('throw(#)', [js.escapedString(comment)]);
}
@override
@@ -5206,10 +5237,10 @@
}
if (node is AsExpression && CoercionReifier.isImplicitCast(node)) {
assert(node.staticType == types.boolType);
- return js.call('dart.test(#)', _visit(node.expression));
+ return _callHelper('test(#)', _visit(node.expression));
}
JS.Expression result = _visit(node);
- if (isNullable(node)) result = js.call('dart.test(#)', result);
+ if (isNullable(node)) result = _callHelper('test(#)', result);
return result;
}
@@ -5217,7 +5248,7 @@
///
/// Unlike call sites, we always have an element available, so we can use it
/// directly rather than computing the relevant options for [_emitMemberName].
- JS.Expression _elementMemberName(ExecutableElement e, {bool useExtension}) {
+ JS.Expression _declareMemberName(ExecutableElement e, {bool useExtension}) {
String name;
if (e is PropertyAccessorElement) {
name = e.variable.name;
@@ -5225,10 +5256,9 @@
name = e.name;
}
return _emitMemberName(name,
- type: (e.enclosingElement as ClassElement).type,
- unary: e.parameters.isEmpty,
isStatic: e.isStatic,
- useExtension: useExtension);
+ useExtension:
+ useExtension ?? _extensionTypes.isNativeClass(e.enclosingElement));
}
/// This handles member renaming for private names and operators.
@@ -5266,17 +5296,13 @@
/// This follows the same pattern as ECMAScript 6 Map:
/// <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map>
///
- /// Unary minus looks like: `x['unary-']()`. Note that [unary] must be passed
- /// for this transformation to happen, otherwise binary minus is assumed.
+ /// Unary minus looks like: `x._negate()`.
///
/// Equality is a bit special, it is generated via the Dart `equals` runtime
/// helper, that checks for null. The user defined method is called '=='.
///
JS.Expression _emitMemberName(String name,
- {DartType type,
- bool unary: false,
- bool isStatic: false,
- bool useExtension}) {
+ {DartType type, bool isStatic: false, bool useExtension}) {
// Static members skip the rename steps.
if (isStatic) return _propertyName(name);
@@ -5284,16 +5310,22 @@
return _emitPrivateNameSymbol(currentLibrary, name);
}
- if (name == '[]') {
- name = 'get';
- } else if (name == '[]=') {
- name = 'set';
- } else if (name == '-' && unary) {
- name = 'unary-';
- } else if (name == 'constructor' || name == 'prototype') {
- // This uses an illegal (in Dart) character for a member, avoiding the
- // conflict. We could use practically any character for this.
- name = '+$name';
+ // When generating synthetic names, we use _ as the prefix, since Dart names
+ // won't have this (eliminated above), nor will static names reach here.
+ switch (name) {
+ case '[]':
+ name = '_get';
+ break;
+ case '[]=':
+ name = '_set';
+ break;
+ case 'unary-':
+ name = '_negate';
+ break;
+ case 'constructor':
+ case 'prototype':
+ name = '_$name';
+ break;
}
var result = _propertyName(name);
@@ -5309,7 +5341,9 @@
!isObjectMember(name);
}
- return useExtension ? js.call('dartx.#', result) : result;
+ return useExtension
+ ? js.call('#.#', [_extensionSymbolsModule, result])
+ : result;
}
JS.TemporaryId _emitPrivateNameSymbol(LibraryElement library, String name) {
@@ -5412,6 +5446,26 @@
}
}
+ JS.Expression _callHelper(String code, [args]) {
+ if (args is List) {
+ args.insert(0, _runtimeModule);
+ } else if (args != null) {
+ args = [_runtimeModule, args];
+ } else {
+ args = _runtimeModule;
+ }
+ return js.call('#.$code', args);
+ }
+
+ JS.Statement _callHelperStatement(String code, args) {
+ if (args is List) {
+ args.insert(0, _runtimeModule);
+ } else {
+ args = [_runtimeModule, args];
+ }
+ return js.statement('#.$code', args);
+ }
+
/// Maps whitelisted files to a list of whitelisted methods
/// within the file.
///
diff --git a/pkg/dev_compiler/lib/src/compiler/command.dart b/pkg/dev_compiler/lib/src/compiler/command.dart
index eff733c..352fb08 100644
--- a/pkg/dev_compiler/lib/src/compiler/command.dart
+++ b/pkg/dev_compiler/lib/src/compiler/command.dart
@@ -81,6 +81,15 @@
}
}
+bool _changed(List<int> list1, List<int> list2) {
+ var length = list1.length;
+ if (length != list2.length) return true;
+ for (var i = 0; i < length; ++i) {
+ if (list1[i] != list2[i]) return true;
+ }
+ return false;
+}
+
void _compile(ArgResults argResults, void printFn(Object obj)) {
var compiler =
new ModuleCompiler(new AnalyzerOptions.fromArguments(argResults));
@@ -150,7 +159,13 @@
if (module.summaryBytes != null) {
var summaryPath =
path.withoutExtension(outPath) + '.${compilerOpts.summaryExtension}';
- new File(summaryPath).writeAsBytesSync(module.summaryBytes);
+ // Only overwrite if summary changed. This plays better with timestamp
+ // based build systems.
+ var file = new File(summaryPath);
+ if (!file.existsSync() ||
+ _changed(file.readAsBytesSync(), module.summaryBytes)) {
+ file.writeAsBytesSync(module.summaryBytes);
+ }
}
}
}
diff --git a/pkg/dev_compiler/lib/src/compiler/js_field_storage.dart b/pkg/dev_compiler/lib/src/compiler/js_field_storage.dart
index decef3b..13d5980 100644
--- a/pkg/dev_compiler/lib/src/compiler/js_field_storage.dart
+++ b/pkg/dev_compiler/lib/src/compiler/js_field_storage.dart
@@ -30,10 +30,6 @@
var setter = superprop.setter;
bool hasSetter = setter != null && !setter.isAbstract;
if (hasSetter) foundSetter = true;
-
- // Stop if this is an abstract getter/setter
- // TODO(jmesserly): why were we doing this?
- if (!hasGetter && !hasSetter) break;
}
return new PropertyOverrideResult(foundGetter, foundSetter);
diff --git a/pkg/dev_compiler/lib/src/compiler/type_utilities.dart b/pkg/dev_compiler/lib/src/compiler/type_utilities.dart
index 27abedd3..7632f08 100644
--- a/pkg/dev_compiler/lib/src/compiler/type_utilities.dart
+++ b/pkg/dev_compiler/lib/src/compiler/type_utilities.dart
@@ -122,13 +122,17 @@
class _GeneratorTable extends _CacheTable {
final _defs = new HashMap<DartType, JS.Expression>();
+ final JS.Identifier _runtimeModule;
+
+ _GeneratorTable(this._runtimeModule);
+
JS.Statement _dischargeType(DartType t) {
var name = _names.remove(t);
if (name != null) {
JS.Expression init = _defs.remove(t);
assert(init != null);
- return js.statement(
- 'let # = () => ((# = dart.constFn(#))());', [name, name, init]);
+ return js.statement('let # = () => ((# = #.constFn(#))());',
+ [name, name, _runtimeModule, init]);
}
return null;
}
@@ -154,10 +158,10 @@
final _definiteCacheNames = new _CacheTable();
/// Generator variable names for hoisted types.
- final _generators = new _GeneratorTable();
+ final _GeneratorTable _generators;
/// Generator variable names for hoisted definite function types.
- final _definiteGenerators = new _GeneratorTable();
+ final _GeneratorTable _definiteGenerators;
/// Mapping from type parameters to the types which must have their
/// cache/generator variables discharged at the binding site for the
@@ -166,6 +170,10 @@
final _scopeDependencies =
new HashMap<TypeParameterElement, List<DartType>>();
+ TypeTable(JS.Identifier runtime)
+ : _generators = new _GeneratorTable(runtime),
+ _definiteGenerators = new _GeneratorTable(runtime);
+
/// Emit a list of statements declaring the cache variables and generator
/// definitions tracked by the table. If [formals] is present, only
/// emit the definitions which depend on the formals.
diff --git a/pkg/dev_compiler/test/browser/language_tests.js b/pkg/dev_compiler/test/browser/language_tests.js
index 25ea068..872dd21 100644
--- a/pkg/dev_compiler/test/browser/language_tests.js
+++ b/pkg/dev_compiler/test/browser/language_tests.js
@@ -413,14 +413,11 @@
'lib/html': {
'async_spawnuri_test': async_unittest,
'async_test': async_unittest,
- 'audiobuffersourcenode_test': 'fail', // sdk#27578.
- 'audiocontext_test': 'fail', // sdk#27578.
- 'blob_constructor_test': 'fail', // sdk#27578.
- 'cache_test': 'fail', // sdk#27578.
+ 'audiocontext_test': 'fail', // was sdk#27578, needs triage
+ 'blob_constructor_test': 'fail', // was sdk#27578, needs triage
'canvas_test': ['unittest'],
'canvasrenderingcontext2d_test': ['unittest'],
'cross_domain_iframe_test': async_unittest,
- 'crypto_test': 'fail', // sdk#27578.
'cssstyledeclaration_test': async_unittest,
'css_test': async_unittest,
@@ -431,8 +428,7 @@
'custom_element_name_clash_test': async_unittest,
'custom_elements_23127_test': async_unittest,
'custom_elements_test': async_unittest,
- 'datalistelement_test': 'fail', // sdk#27578.
- 'dom_constructors_test': 'fail', // sdk#27578.
+ 'dom_constructors_test': 'fail', // was sdk#27578, needs triage
'element_animate_test': async_unittest,
'element_classes_test': 'fail', // sdk#27579.
'element_classes_svg_test': 'fail', // sdk#27579.
@@ -440,7 +436,6 @@
// Failure: 'Expected 56 to be in the inclusive range [111, 160].'.
'element_offset_test': 'fail',
'element_test': async_unittest,
- 'element_types_test': 'fail', // sdk#27578.
'event_customevent_test': async_unittest,
'events_test': async_unittest,
@@ -460,7 +455,7 @@
'indexeddb_3_test': async_unittest,
'indexeddb_4_test': async_unittest,
'indexeddb_5_test': async_unittest,
- 'input_element_test': 'fail', // sdk#27578.
+ 'input_element_test': 'fail', // was sdk#27578, needs triage
'interactive_test': async_unittest,
'isolates_test': async_unittest,
@@ -475,32 +470,26 @@
'js_util_test': 'fail',
'keyboard_event_test': async_unittest,
- 'mediasource_test': 'fail', // sdk#27578.
- 'media_stream_test': 'fail', // sdk#27578.
- 'messageevent_test': 'fail', // sdk#27578.
+ 'mediasource_test': 'fail', // was sdk#27578, needs triage
+ 'media_stream_test': 'fail', // was sdk#27578, needs triage
+ 'messageevent_test': 'fail', // was sdk#27578, needs triage
// Should throw but does not.
'mirrors_js_typed_interop_test': 'fail',
'mutationobserver_test': async_unittest,
'native_gc_test': async_unittest,
- 'node_validator_important_if_you_suppress_make_the_bug_critical_test': 'fail', // sdk#27578.
- 'notification_test': 'fail', // sdk#27578.
- 'performance_api_test': 'fail', // sdk#27578.
+ 'notification_test': 'fail', // was sdk#27578, needs triage
'postmessage_structured_test': async_unittest,
- 'range_test': 'fail', // sdk#27578.
'request_animation_frame_test': async_unittest,
'resource_http_test': async_unittest,
- 'rtc_test': 'fail', // sdk#27578.
+ 'rtc_test': 'fail', // was sdk#27578, needs triage
// Expected 1, got null.
'serialized_script_value_test': 'fail',
- 'shadow_dom_test': 'fail', // sdk#27578.
- 'shadowroot_test': 'fail', // sdk#27578.
- 'speechrecognition_test': 'fail', // sdk#27578.
- 'svgelement_test': 'fail', // sdk#27578.
- 'touchevent_test': 'fail', // sdk#27578.
- 'track_element_constructor_test': 'fail', // sdk#27578.
+ 'speechrecognition_test': 'fail', // was sdk#27578, needs triage
+ 'svgelement_test': 'fail', // was sdk#27578, needs triage
+ 'touchevent_test': 'fail', // was sdk#27578, needs triage
'transferables_test': async_unittest,
'transition_event_test': async_unittest,
'url_test': async_unittest,
@@ -512,7 +501,6 @@
'xhr_cross_origin_test': async_unittest,
'xhr_test': async_unittest,
- 'xsltprocessor_test': 'fail', // sdk#27578.
// Failing when it gets 3 instead of 42.
'js_typed_interop_default_arg_test_default_value_multi': 'fail',
@@ -536,7 +524,6 @@
'math2_test': skip_fail,
'pi_test': skip_timeout,
'random_big_test': skip_fail,
- 'rectangle_test': fail, // TODO(rnystrom): #27551
},
'lib/typed_data': {
diff --git a/pkg/dev_compiler/test/codegen/language/mixin_abstract_getter_test.dart b/pkg/dev_compiler/test/codegen/language/mixin_abstract_getter_test.dart
new file mode 100644
index 0000000..98ee18c
--- /dev/null
+++ b/pkg/dev_compiler/test/codegen/language/mixin_abstract_getter_test.dart
@@ -0,0 +1,43 @@
+// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:expect/expect.dart';
+
+abstract class B {
+ int get x;
+}
+
+class C {
+ int get x => 42;
+}
+
+class D extends C with B {
+ final int x;
+
+ D(this.x);
+}
+
+
+class C2 {
+ int get x => 42;
+}
+
+abstract class B2 extends C2 {
+ int get x;
+}
+
+class D2 extends B2 {
+ final int x;
+
+ D2(this.x);
+}
+
+
+void main() {
+ var d = new D(17);
+ Expect.equals(d.x, 17);
+
+ var d2 = new D2(17);
+ Expect.equals(d.x, 17);
+}
diff --git a/pkg/dev_compiler/test/codegen/language/variable_named_dart_test.dart b/pkg/dev_compiler/test/codegen/language/variable_named_dart_test.dart
new file mode 100644
index 0000000..233b60f
--- /dev/null
+++ b/pkg/dev_compiler/test/codegen/language/variable_named_dart_test.dart
@@ -0,0 +1,10 @@
+// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:expect/expect.dart';
+
+main() {
+ dynamic dart = 123;
+ Expect.equals(dart.toDouble(), 123.0);
+}
diff --git a/pkg/dev_compiler/test/codegen/lib/math/implement_rectangle_test.dart b/pkg/dev_compiler/test/codegen/lib/math/implement_rectangle_test.dart
new file mode 100644
index 0000000..3a31ed8
--- /dev/null
+++ b/pkg/dev_compiler/test/codegen/lib/math/implement_rectangle_test.dart
@@ -0,0 +1,80 @@
+// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:math' hide Rectangle;
+import 'dart:math' as math show Point, Rectangle, MutableRectangle;
+import 'package:expect/expect.dart' show Expect;
+
+void main() {
+ verifyRectable(new Rectangle(1, 2, 3, 4));
+}
+
+void verifyRectable(math.Rectangle rect) {
+ Expect.equals(1.0, rect.left.toDouble());
+ Expect.equals(2.0, rect.top.toDouble());
+ Expect.equals(4.0, rect.right.toDouble());
+ Expect.equals(6.0, rect.bottom.toDouble());
+}
+
+class Rectangle<T extends num> implements math.MutableRectangle<T> {
+ T left;
+ T top;
+ T width;
+ T height;
+
+ Rectangle(this.left, this.top, this.width, this.height);
+
+ T get right => left + width;
+
+ T get bottom => top + height;
+
+ Point<T> get topLeft => new Point<T>(left, top);
+
+ Point<T> get topRight => new Point<T>(right, top);
+
+ Point<T> get bottomLeft => new Point<T>(left, bottom);
+
+ Point<T> get bottomRight => new Point<T>(right, bottom);
+
+ //---------------------------------------------------------------------------
+
+ bool contains(num px, num py) {
+ return left <= px && top <= py && right > px && bottom > py;
+ }
+
+ bool containsPoint(math.Point<num> p) {
+ return contains(p.x, p.y);
+ }
+
+ bool intersects(math.Rectangle<num> r) {
+ return left < r.right && right > r.left && top < r.bottom && bottom > r.top;
+ }
+
+ /// Returns a new rectangle which completely contains `this` and [other].
+
+ Rectangle<T> boundingBox(math.Rectangle<T> other) {
+ T rLeft = min(left, other.left);
+ T rTop = min(top, other.top);
+ T rRight = max(right, other.right);
+ T rBottom = max(bottom, other.bottom);
+ return new Rectangle<T>(rLeft, rTop, rRight - rLeft, rBottom - rTop);
+ }
+
+ /// Tests whether `this` entirely contains [another].
+
+ bool containsRectangle(math.Rectangle<num> r) {
+ return left <= r.left &&
+ top <= r.top &&
+ right >= r.right &&
+ bottom >= r.bottom;
+ }
+
+ Rectangle<T> intersection(math.Rectangle<T> rect) {
+ T rLeft = max(left, rect.left);
+ T rTop = max(top, rect.top);
+ T rRight = min(right, rect.right);
+ T rBottom = min(bottom, rect.bottom);
+ return new Rectangle<T>(rLeft, rTop, rRight - rLeft, rBottom - rTop);
+ }
+}
diff --git a/pkg/dev_compiler/test/codegen_expected/BenchmarkBase.js b/pkg/dev_compiler/test/codegen_expected/BenchmarkBase.js
index 7535ac0..48a5eb6 100644
--- a/pkg/dev_compiler/test/codegen_expected/BenchmarkBase.js
+++ b/pkg/dev_compiler/test/codegen_expected/BenchmarkBase.js
@@ -16,7 +16,7 @@
dart.throw(dart.str`Lists have different lengths: ${expected[dartx.length]} vs ${actual[dartx.length]}`);
}
for (let i = 0; i < dart.notNull(actual[dartx.length]); i++) {
- BenchmarkBase$.Expect.equals(expected[dartx.get](i), actual[dartx.get](i));
+ BenchmarkBase$.Expect.equals(expected[dartx._get](i), actual[dartx._get](i));
}
}
fail(message) {
diff --git a/pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/classes.dart b/pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/classes.dart
index f6b12eb..87ed08b 100644
--- a/pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/classes.dart
+++ b/pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/classes.dart
@@ -459,11 +459,6 @@
let proto = $type.prototype;
for (let name of $methodNames) {
let method = $getOwnPropertyDescriptor(proto, name);
- // TODO(vsm): We should be able to generate code to avoid this case.
- // The method may be null if this type implements a potentially native
- // interface but isn't native itself. For a field on this type, we're not
- // generating a corresponding getter/setter method - it's just a field.
- if (!method) continue;
$defineProperty(proto, $getExtensionSymbol(name), method);
}
// Ensure the signature is available too.
diff --git a/pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/operations.dart b/pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/operations.dart
index ba0dbc6..946507c 100644
--- a/pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/operations.dart
+++ b/pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/operations.dart
@@ -312,10 +312,10 @@
dgsend(obj, typeArgs, method, @rest args) =>
_callMethod(obj, method, typeArgs, args, method);
-dindex(obj, index) => _callMethod(obj, 'get', null, JS('', '[#]', index), '[]');
+dindex(obj, index) => _callMethod(obj, '_get', null, JS('', '[#]', index), '[]');
dsetindex(obj, index, value) =>
- _callMethod(obj, 'set', null, JS('', '[#, #]', index, value), '[]=');
+ _callMethod(obj, '_set', null, JS('', '[#, #]', index, value), '[]=');
/// TODO(leafp): This duplicates code in types.dart.
/// I haven't found a way to factor it out that makes the
@@ -535,11 +535,11 @@
for (let i = 0, end = $values.length - 1; i < end; i += 2) {
let key = $values[i];
let value = $values[i + 1];
- map.set(key, value);
+ map._set(key, value);
}
} else if (typeof $values === 'object') {
for (let key of $getOwnPropertyNames($values)) {
- map.set(key, $values[key]);
+ map._set(key, $values[key]);
}
}
return map;
diff --git a/pkg/dev_compiler/tool/run.js b/pkg/dev_compiler/tool/run.js
index 4d186072..b27a007 100644
--- a/pkg/dev_compiler/tool/run.js
+++ b/pkg/dev_compiler/tool/run.js
@@ -9,11 +9,19 @@
var test = args[0];
var requirejs = require('requirejs');
-var ddcdir = __dirname + '/..';
+var ddcdir = __dirname + '/../';
requirejs.config({
- baseUrl: ddcdir + '/gen/codegen_output',
+ baseUrl: ddcdir + 'gen/codegen_output',
paths: {
- dart_sdk: ddcdir + '/lib/js/amd/dart_sdk'
+ dart_sdk: ddcdir + 'lib/js/amd/dart_sdk',
+ async_helper: ddcdir + 'gen/codegen_output/pkg/async_helper',
+ expect: ddcdir + 'gen/codegen_output/pkg/expect',
+ js: ddcdir + 'gen/codegen_output/pkg/js',
+ matcher: ddcdir + 'gen/codegen_output/pkg/matcher',
+ minitest: ddcdir + 'gen/codegen_output/pkg/minitest',
+ path: ddcdir + 'gen/codegen_output/pkg/path',
+ stack_trace: ddcdir + 'gen/codegen_output/pkg/stack_trace',
+ unittest: ddcdir + 'gen/codegen_output/pkg/unittest',
}
});
diff --git a/pkg/front_end/lib/compilation_error.dart b/pkg/front_end/lib/compilation_error.dart
index 2211ae9..a238575 100644
--- a/pkg/front_end/lib/compilation_error.dart
+++ b/pkg/front_end/lib/compilation_error.dart
@@ -13,14 +13,14 @@
///
/// TODO(paulberry): add a reference to the analyzer error code.
///
-/// TODO(paulberry): add a correction message, once most analyzer errors have
-/// one.
-///
/// Not intended to be implemented or extended by clients.
abstract class CompilationError {
- /// A text description of the compile error.
- String get message;
+ /// A text description of how the user can fix the error. May be `null`.
+ String get correction;
/// The source location where the error occurred.
SourceSpan get location;
+
+ /// A text description of the compile error.
+ String get message;
}
diff --git a/pkg/front_end/pubspec.yaml b/pkg/front_end/pubspec.yaml
index 1c8fdd8..9c09fa2 100644
--- a/pkg/front_end/pubspec.yaml
+++ b/pkg/front_end/pubspec.yaml
@@ -9,3 +9,11 @@
analyzer: '^0.29.0'
path: '^1.3.9'
source_span: '^1.2.3'
+dev_dependencies:
+ package_config: '^1.0.0'
+ # TODO(sigmund): update to a version constraint once we roll the latest kernel
+ # to the repo.
+ kernel: {path: ../../third_party/pkg/kernel}
+# TODO(sigmund): remove once kernel is moved into the sdk repo.
+dependency_overrides:
+ analyzer: '^0.29.0'
diff --git a/pkg/front_end/tool/perf.dart b/pkg/front_end/tool/perf.dart
new file mode 100644
index 0000000..e8d50a8
--- /dev/null
+++ b/pkg/front_end/tool/perf.dart
@@ -0,0 +1,245 @@
+// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// An entrypoint used to run portions of front_end and measure its performance.
+library front_end.tool.perf;
+
+import 'dart:async';
+import 'dart:io' show exit, stderr;
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/error/listener.dart';
+import 'package:analyzer/file_system/file_system.dart' show ResourceUriResolver;
+import 'package:analyzer/file_system/physical_file_system.dart'
+ show PhysicalResourceProvider;
+import 'package:analyzer/source/package_map_resolver.dart';
+import 'package:analyzer/src/context/builder.dart';
+import 'package:analyzer/src/dart/scanner/reader.dart';
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/dart/sdk/sdk.dart' show FolderBasedDartSdk;
+import 'package:analyzer/src/generated/parser.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/source_io.dart';
+import 'package:kernel/analyzer/loader.dart';
+import 'package:kernel/kernel.dart';
+import 'package:package_config/discovery.dart';
+
+/// Cumulative total number of chars scanned.
+int scanTotalChars = 0;
+
+/// Cumulative time spent scanning.
+Stopwatch scanTimer = new Stopwatch();
+
+/// Factory to load and resolve app, packages, and sdk sources.
+SourceFactory sources;
+
+main(List<String> args) async {
+ // TODO(sigmund): provide sdk folder as well.
+ if (args.length < 2) {
+ print('usage: perf.dart <bench-id> <entry.dart>');
+ exit(1);
+ }
+ var totalTimer = new Stopwatch()..start();
+
+ var bench = args[0];
+ var entryUri = Uri.base.resolve(args[1]);
+
+ await setup(entryUri);
+
+ var handlers = {
+ 'scan': () async {
+ Set<Source> files = scanReachableFiles(entryUri);
+ // TODO(sigmund): replace the warmup with instrumented snapshots.
+ for (int i = 0; i < 10; i++) scanFiles(files);
+ },
+ 'parse': () async {
+ Set<Source> files = scanReachableFiles(entryUri);
+ // TODO(sigmund): replace the warmup with instrumented snapshots.
+ for (int i = 0; i < 10; i++) parseFiles(files);
+ },
+ 'kernel_gen_e2e': () async {
+ // TODO(sigmund): remove. This is used to compute the input size, we
+ // should extract input size from frontend instead.
+ scanReachableFiles(entryUri);
+ // TODO(sigmund): replace this warmup. Note that for very large programs,
+ // the GC pressure on the VM seems to make this worse with time (maybe we
+ // are leaking memory?). That's why we run it twice and not 10 times.
+ for (int i = 0; i < 2; i++) await generateKernel(entryUri);
+ },
+ };
+
+ var handler = handlers[bench];
+ if (handler == null) {
+ // TODO(sigmund): implement the remaining benchmarks.
+ print('unsupported bench-id: $bench. Please specify one of the following: '
+ '${handler.keys.join(", ")}');
+ exit(1);
+ }
+ await handler();
+
+ totalTimer.stop();
+ report("total", totalTimer.elapsedMicroseconds);
+}
+
+/// Sets up analyzer to be able to load and resolve app, packages, and sdk
+/// sources.
+Future setup(Uri entryUri) async {
+ var provider = PhysicalResourceProvider.INSTANCE;
+ var packageMap = new ContextBuilder(provider, null, null)
+ .convertPackagesToMap(await findPackages(entryUri));
+ sources = new SourceFactory([
+ new ResourceUriResolver(provider),
+ new PackageMapUriResolver(provider, packageMap),
+ new DartUriResolver(
+ new FolderBasedDartSdk(provider, provider.getFolder("sdk"))),
+ ]);
+}
+
+/// Load and scans all files we need to process: files reachable from the
+/// entrypoint and all core libraries automatically included by the VM.
+Set<Source> scanReachableFiles(Uri entryUri) {
+ var files = new Set<Source>();
+ var loadTimer = new Stopwatch()..start();
+ collectSources(sources.forUri2(entryUri), files);
+
+ var libs = [
+ "dart:async",
+ "dart:collection",
+ "dart:convert",
+ "dart:core",
+ "dart:developer",
+ "dart:_internal",
+ "dart:isolate",
+ "dart:math",
+ "dart:mirrors",
+ "dart:typed_data",
+ "dart:io"
+ ];
+
+ for (var lib in libs) {
+ collectSources(sources.forUri(lib), files);
+ }
+
+ loadTimer.stop();
+
+ print('input size: ${scanTotalChars} chars');
+ var loadTime = loadTimer.elapsedMicroseconds - scanTimer.elapsedMicroseconds;
+ report("load", loadTime);
+ report("scan", scanTimer.elapsedMicroseconds);
+ return files;
+}
+
+/// Scans every file in [files] and reports the time spent doing so.
+void scanFiles(Set<Source> files) {
+ // The code below will record again how many chars are scanned and how long it
+ // takes to scan them, even though we already did so in [scanReachableFiles].
+ // Recording and reporting this twice is unnecessary, but we do so for now to
+ // validate that the results are consistent.
+ scanTimer = new Stopwatch();
+ var old = scanTotalChars;
+ scanTotalChars = 0;
+ for (var source in files) {
+ tokenize(source);
+ }
+
+ // Report size and scanning time again. See discussion above.
+ if (old != scanTotalChars) print('input size changed? ${old} chars');
+ report("scan", scanTimer.elapsedMicroseconds);
+}
+
+/// Parses every file in [files] and reports the time spent doing so.
+void parseFiles(Set<Source> files) {
+ // The code below will record again how many chars are scanned and how long it
+ // takes to scan them, even though we already did so in [scanReachableFiles].
+ // Recording and reporting this twice is unnecessary, but we do so for now to
+ // validate that the results are consistent.
+ scanTimer = new Stopwatch();
+ var old = scanTotalChars;
+ scanTotalChars = 0;
+ var parseTimer = new Stopwatch()..start();
+ for (var source in files) {
+ parseFull(source);
+ }
+ parseTimer.stop();
+
+ // Report size and scanning time again. See discussion above.
+ if (old != scanTotalChars) print('input size changed? ${old} chars');
+ report("scan", scanTimer.elapsedMicroseconds);
+
+ var pTime = parseTimer.elapsedMicroseconds - scanTimer.elapsedMicroseconds;
+ report("parse", pTime);
+}
+
+/// Add to [files] all sources reachable from [start].
+void collectSources(Source start, Set<Source> files) {
+ if (!files.add(start)) return;
+ var unit = parseDirectives(start);
+ for (var directive in unit.directives) {
+ if (directive is UriBasedDirective) {
+ var next = sources.resolveUri(start, directive.uri.stringValue);
+ collectSources(next, files);
+ }
+ }
+}
+
+/// Uses the diet-parser to parse only directives in [source].
+CompilationUnit parseDirectives(Source source) {
+ var token = tokenize(source);
+ var parser = new Parser(source, AnalysisErrorListener.NULL_LISTENER);
+ return parser.parseDirectives(token);
+}
+
+/// Parse the full body of [source] and return it's compilation unit.
+CompilationUnit parseFull(Source source) {
+ var token = tokenize(source);
+ var parser = new Parser(source, AnalysisErrorListener.NULL_LISTENER);
+ return parser.parseCompilationUnit(token);
+}
+
+/// Scan [source] and return the first token produced by the scanner.
+Token tokenize(Source source) {
+ scanTimer.start();
+ var contents = source.contents.data;
+ scanTotalChars += contents.length;
+ // TODO(sigmund): is there a way to scan from a random-access-file without
+ // first converting to String?
+ var scanner = new Scanner(source, new CharSequenceReader(contents),
+ AnalysisErrorListener.NULL_LISTENER)..preserveComments = false;
+ var token = scanner.tokenize();
+ scanTimer.stop();
+ return token;
+}
+
+/// Report that metric [name] took [time] micro-seconds to process
+/// [scanTotalChars] characters.
+void report(String name, int time) {
+ var sb = new StringBuffer();
+ sb.write('$name: $time us, ${time ~/ 1000} ms');
+ sb.write(', ${scanTotalChars * 1000 ~/ time} chars/ms');
+ print('$sb');
+}
+
+// TODO(sigmund): replace this once kernel is produced by the frontend directly.
+Future<Program> generateKernel(Uri entryUri) async {
+ var dartkTimer = new Stopwatch()..start();
+ var options = new DartOptions(strongMode: false, sdk: 'sdk');
+ var packages =
+ await createPackages(options.packagePath, discoveryPath: entryUri.path);
+ var repository = new Repository();
+ DartLoader loader = new DartLoader(repository, options, packages);
+
+ Program program = loader.loadProgram(entryUri.path);
+ List errors = loader.errors;
+ if (errors.isNotEmpty) {
+ const int errorLimit = 100;
+ stderr.writeln(errors.take(errorLimit).join('\n'));
+ if (errors.length > errorLimit) {
+ stderr.writeln('[error] ${errors.length - errorLimit} errors not shown');
+ }
+ }
+ dartkTimer.stop();
+ report("kernel_gen_e2e", dartkTimer.elapsedMicroseconds);
+ return program;
+}
diff --git a/pkg/front_end/tool/perf_test.dart b/pkg/front_end/tool/perf_test.dart
new file mode 100644
index 0000000..5abc06f
--- /dev/null
+++ b/pkg/front_end/tool/perf_test.dart
@@ -0,0 +1,11 @@
+// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// The only purpose of this file is to enable analyzer tests on `perf.dart`,
+/// the code here just has a dummy import to the rest of the code.
+library front_end.tool.perf_test;
+
+import 'perf.dart' as m;
+
+main() => print('done ${m.scanTotalChars}');
diff --git a/pkg/pkg.status b/pkg/pkg.status
index 0219688..d0913e6 100644
--- a/pkg/pkg.status
+++ b/pkg/pkg.status
@@ -50,6 +50,7 @@
collection/test/equality_test/05: Fail # Issue 1533
collection/test/equality_test/none: Pass, Fail # Issue 14348
compiler/tool/*: SkipByDesign # Only meant to run on vm
+front_end/tool/*: SkipByDesign # Only meant to run on vm
lookup_map/test/version_check_test: SkipByDesign # Only meant to run in vm.
typed_data/test/typed_buffers_test/01: Fail # Not supporting Int64List, Uint64List.
@@ -98,6 +99,7 @@
analyzer/tool/summary/check_test: SkipByDesign # Uses dart:io.
analyzer2dart/*: SkipByDesign # Uses dart:io.
compiler/tool/*: SkipByDesign # Only meant to run on vm
+front_end/tool/*: SkipByDesign # Only meant to run on vm
http_server/test/*: Fail, OK # Uses dart:io.
observe/test/transformer_test: Fail, OK # Uses dart:io.
observe/test/unique_message_test: SkipByDesign # Uses dart:io.
diff --git a/pkg/pkgbuild.status b/pkg/pkgbuild.status
index 20e54e1..cefeb2f 100644
--- a/pkg/pkgbuild.status
+++ b/pkg/pkgbuild.status
@@ -7,6 +7,8 @@
[ ($use_repository_packages || $use_public_packages) ]
pkg/dev_compiler: SkipByDesign # we have relative paths to analyzer
+pkg/analyzer: Fail # Issue 27654
+pkg/front_end: Fail # Issue 27655
[ $use_repository_packages ]
# third_party/pkg/dart2js_info: Fail # Issue https://github.com/dart-lang/dart2js_info/pull/14
diff --git a/runtime/bin/directory_win.cc b/runtime/bin/directory_win.cc
index efaaaf9..4ebf512 100644
--- a/runtime/bin/directory_win.cc
+++ b/runtime/bin/directory_win.cc
@@ -50,8 +50,8 @@
bool PathBuffer::Add(const char* name) {
- const wchar_t* wide_name = StringUtilsWin::Utf8ToWide(name);
- return AddW(wide_name);
+ Utf8ToWideScope wide_name(name);
+ return AddW(wide_name.wide());
}
@@ -377,8 +377,8 @@
Directory::ExistsResult Directory::Exists(const char* dir_name) {
- const wchar_t* system_name = StringUtilsWin::Utf8ToWide(dir_name);
- return ExistsHelper(system_name);
+ Utf8ToWideScope system_name(dir_name);
+ return ExistsHelper(system_name.wide());
}
@@ -412,19 +412,19 @@
bool Directory::SetCurrent(const char* path) {
- const wchar_t* system_path = StringUtilsWin::Utf8ToWide(path);
- bool result = SetCurrentDirectoryW(system_path) != 0;
+ Utf8ToWideScope system_path(path);
+ bool result = SetCurrentDirectoryW(system_path.wide()) != 0;
return result;
}
bool Directory::Create(const char* dir_name) {
- const wchar_t* system_name = StringUtilsWin::Utf8ToWide(dir_name);
- int create_status = CreateDirectoryW(system_name, NULL);
+ Utf8ToWideScope system_name(dir_name);
+ int create_status = CreateDirectoryW(system_name.wide(), NULL);
// If the directory already existed, treat it as a success.
if ((create_status == 0) &&
(GetLastError() == ERROR_ALREADY_EXISTS) &&
- (ExistsHelper(system_name) == EXISTS)) {
+ (ExistsHelper(system_name.wide()) == EXISTS)) {
return true;
}
return (create_status != 0);
@@ -446,8 +446,8 @@
// descriptor inherited from its parent directory.
// The return value is Dart_ScopeAllocated.
PathBuffer path;
- const wchar_t* system_prefix = StringUtilsWin::Utf8ToWide(prefix);
- if (!path.AddW(system_prefix)) {
+ Utf8ToWideScope system_prefix(prefix);
+ if (!path.AddW(system_prefix.wide())) {
return NULL;
}
@@ -481,16 +481,16 @@
bool Directory::Delete(const char* dir_name, bool recursive) {
bool result = false;
- const wchar_t* system_dir_name = StringUtilsWin::Utf8ToWide(dir_name);
+ Utf8ToWideScope system_dir_name(dir_name);
if (!recursive) {
if (File::GetType(dir_name, true) == File::kIsDirectory) {
- result = (RemoveDirectoryW(system_dir_name) != 0);
+ result = (RemoveDirectoryW(system_dir_name.wide()) != 0);
} else {
SetLastError(ERROR_FILE_NOT_FOUND);
}
} else {
PathBuffer path;
- if (path.AddW(system_dir_name)) {
+ if (path.AddW(system_dir_name.wide())) {
result = DeleteRecursively(&path);
}
}
@@ -499,13 +499,13 @@
bool Directory::Rename(const char* path, const char* new_path) {
- const wchar_t* system_path = StringUtilsWin::Utf8ToWide(path);
- const wchar_t* system_new_path = StringUtilsWin::Utf8ToWide(new_path);
- ExistsResult exists = ExistsHelper(system_path);
+ Utf8ToWideScope system_path(path);
+ Utf8ToWideScope system_new_path(new_path);
+ ExistsResult exists = ExistsHelper(system_path.wide());
if (exists != EXISTS) {
return false;
}
- ExistsResult new_exists = ExistsHelper(system_new_path);
+ ExistsResult new_exists = ExistsHelper(system_new_path.wide());
// MoveFile does not allow replacing exising directories. Therefore,
// if the new_path is currently a directory we need to delete it
// first.
@@ -517,7 +517,7 @@
}
DWORD flags = MOVEFILE_WRITE_THROUGH;
int move_status =
- MoveFileExW(system_path, system_new_path, flags);
+ MoveFileExW(system_path.wide(), system_new_path.wide(), flags);
return (move_status != 0);
}
diff --git a/runtime/bin/eventhandler_fuchsia.cc b/runtime/bin/eventhandler_fuchsia.cc
index 2a61164..0d52f55 100644
--- a/runtime/bin/eventhandler_fuchsia.cc
+++ b/runtime/bin/eventhandler_fuchsia.cc
@@ -13,18 +13,146 @@
#include <magenta/status.h>
#include <magenta/syscalls.h>
+#include "bin/log.h"
#include "bin/thread.h"
#include "bin/utils.h"
+#if defined(EVENTHANDLER_LOGGING)
+#define LOG_ERR(msg, ...) Log::PrintErr(msg, ##__VA_ARGS__)
+#define LOG_INFO(msg, ...) Log::Print(msg, ##__VA_ARGS__)
+#else
+#define LOG_ERR(msg, ...)
+#define LOG_INFO(msg, ...)
+#endif // defined(EVENTHANDLER_LOGGING)
+
namespace dart {
namespace bin {
+MagentaWaitManyInfo::MagentaWaitManyInfo()
+ : capacity_(kInitialCapacity),
+ size_(0) {
+ descriptor_infos_ = static_cast<DescriptorInfo**>(
+ malloc(kInitialCapacity * sizeof(*descriptor_infos_)));
+ if (descriptor_infos_ == NULL) {
+ FATAL("Failed to allocate descriptor_infos array");
+ }
+ handles_ = static_cast<mx_handle_t*>(
+ malloc(kInitialCapacity * sizeof(*handles_)));
+ if (handles_ == NULL) {
+ FATAL("Failed to allocate handles array");
+ }
+ signals_ = static_cast<mx_signals_t*>(
+ malloc(kInitialCapacity * sizeof(*signals_)));
+ if (signals_ == NULL) {
+ FATAL("Failed to allocate signals array");
+ }
+ signals_states_ = static_cast<mx_signals_state_t*>(
+ malloc(kInitialCapacity * sizeof(*signals_states_)));
+ if (signals_states_ == NULL) {
+ FATAL("Failed to allocate signals_states array");
+ }
+}
+
+
+MagentaWaitManyInfo::~MagentaWaitManyInfo() {
+ free(descriptor_infos_);
+ free(handles_);
+ free(signals_);
+ free(signals_states_);
+}
+
+
+void MagentaWaitManyInfo::AddHandle(mx_handle_t handle,
+ mx_signals_t signals,
+ DescriptorInfo* di) {
+#if defined(DEBUG)
+ // Check that the handle is not already in the list.
+ for (intptr_t i = 0; i < size_; i++) {
+ if (handles_[i] == handle) {
+ FATAL("The handle is already in the list!");
+ }
+ }
+#endif
+ intptr_t new_size = size_ + 1;
+ GrowArraysIfNeeded(new_size);
+ descriptor_infos_[size_] = di;
+ handles_[size_] = handle;
+ signals_[size_] = signals;
+ signals_states_[size_].satisfied = MX_SIGNAL_NONE;
+ signals_states_[size_].satisfiable = MX_SIGNAL_NONE;
+ size_ = new_size;
+ LOG_INFO("AddHandle(%ld, %ld, %p), size = %ld\n", handle, signals, di, size_);
+}
+
+
+void MagentaWaitManyInfo::RemoveHandle(mx_handle_t handle) {
+ intptr_t idx;
+ for (idx = 1; idx < size_; idx++) {
+ if (handle == handles_[idx]) {
+ break;
+ }
+ }
+ if (idx == size_) {
+ FATAL("Handle is not in the list!");
+ }
+
+ if (idx != (size_ - 1)) {
+ descriptor_infos_[idx] = descriptor_infos_[size_ - 1];
+ handles_[idx] = handles_[size_ - 1];
+ signals_[idx] = signals_[size_ - 1];
+ signals_states_[idx] = signals_states_[size_ - 1];
+ }
+ descriptor_infos_[size_ - 1] = NULL;
+ handles_[size_ - 1] = MX_HANDLE_INVALID;
+ signals_[size_ - 1] = MX_SIGNAL_NONE;
+ signals_states_[size_ - 1].satisfied = MX_SIGNAL_NONE;
+ signals_states_[size_ - 1].satisfiable = MX_SIGNAL_NONE;
+ size_ = size_ - 1;
+ LOG_INFO("RemoveHandle(%ld), size = %ld\n", handle, size_);
+}
+
+
+void MagentaWaitManyInfo::GrowArraysIfNeeded(intptr_t desired_size) {
+ if (desired_size < capacity_) {
+ return;
+ }
+ intptr_t new_capacity = desired_size + (desired_size >> 1);
+ descriptor_infos_ = static_cast<DescriptorInfo**>(
+ realloc(descriptor_infos_, new_capacity * sizeof(*descriptor_infos_)));
+ if (descriptor_infos_ == NULL) {
+ FATAL("Failed to grow descriptor_infos array");
+ }
+ handles_ = static_cast<mx_handle_t*>(
+ realloc(handles_, new_capacity * sizeof(*handles_)));
+ if (handles_ == NULL) {
+ FATAL("Failed to grow handles array");
+ }
+ signals_ = static_cast<mx_signals_t*>(
+ realloc(signals_, new_capacity * sizeof(*signals_)));
+ if (signals_ == NULL) {
+ FATAL("Failed to grow signals array");
+ }
+ signals_states_ = static_cast<mx_signals_state_t*>(
+ realloc(signals_states_, new_capacity * sizeof(*signals_states_)));
+ if (signals_states_ == NULL) {
+ FATAL("Failed to grow signals_states array");
+ }
+ capacity_ = new_capacity;
+ LOG_INFO("GrowArraysIfNeeded(%ld), capacity = %ld\n",
+ desired_size, capacity_);
+}
+
+
EventHandlerImplementation::EventHandlerImplementation() {
mx_status_t status = mx_msgpipe_create(interrupt_handles_, 0);
if (status != NO_ERROR) {
FATAL1("mx_msgpipe_create failed: %s\n", mx_status_get_string(status));
}
shutdown_ = false;
+ info_.AddHandle(interrupt_handles_[0],
+ MX_SIGNAL_READABLE | MX_SIGNAL_PEER_CLOSED,
+ NULL);
+ LOG_INFO("EventHandlerImplementation initialized\n");
}
@@ -37,6 +165,7 @@
if (status != NO_ERROR) {
FATAL1("mx_handle_close failed: %s\n", mx_status_get_string(status));
}
+ LOG_INFO("EventHandlerImplementation destroyed\n");
}
@@ -53,10 +182,12 @@
if (status != NO_ERROR) {
FATAL1("mx_msgpipe_write failed: %s\n", mx_status_get_string(status));
}
+ LOG_INFO("WakeupHandler(%ld, %ld, %lld)\n", id, dart_port, data);
}
void EventHandlerImplementation::HandleInterruptFd() {
+ LOG_INFO("HandleInterruptFd entry\n");
InterruptMessage msg;
uint32_t bytes = kInterruptMessageSize;
mx_status_t status;
@@ -68,25 +199,48 @@
}
ASSERT(bytes == kInterruptMessageSize);
if (msg.id == kTimerId) {
+ LOG_INFO("HandleInterruptFd read timer update\n");
timeout_queue_.UpdateTimeout(msg.dart_port, msg.data);
} else if (msg.id == kShutdownId) {
+ LOG_INFO("HandleInterruptFd read shutdown\n");
shutdown_ = true;
} else {
+ // TODO(zra): Handle commands to add and remove handles from the
+ // MagentaWaitManyInfo.
UNIMPLEMENTED();
}
}
- // status == ERR_BAD_STATE when we try to read and there are no messages
- // available, so it is an error if we get here and status != ERR_BAD_STATE.
- if (status != ERR_BAD_STATE) {
+ // status == ERR_SHOULD_WAIT when we try to read and there are no messages
+ // available, so it is an error if we get here and status != ERR_SHOULD_WAIT.
+ if (status != ERR_SHOULD_WAIT) {
FATAL1("mx_msgpipe_read failed: %s\n", mx_status_get_string(status));
}
+ LOG_INFO("HandleInterruptFd exit\n");
}
void EventHandlerImplementation::HandleEvents() {
- // TODO(zra): Handle events from other handles. At the moment we are only
- // interrupted when there is a message on interrupt_handles_[0].
- HandleInterruptFd();
+ LOG_INFO("HandleEvents entry\n");
+ for (intptr_t i = 1; i < info_.size(); i++) {
+ if (info_.signals_states()[i].satisfied != MX_SIGNAL_NONE) {
+ // Only the control handle has no descriptor info.
+ ASSERT(info_.descriptor_infos()[i] != NULL);
+ ASSERT(info_.handles()[i] != interrupt_handles_[0]);
+ // TODO(zra): Handle events on other handles. At the moment we are
+ // only interrupted when there is a message on interrupt_handles_[0].
+ UNIMPLEMENTED();
+ }
+ }
+
+ if ((info_.signals_states()[0].satisfied & MX_SIGNAL_PEER_CLOSED) != 0) {
+ FATAL("EventHandlerImplementation::Poll: Unexpected peer closed\n");
+ }
+ if ((info_.signals_states()[0].satisfied & MX_SIGNAL_READABLE) != 0) {
+ LOG_INFO("HandleEvents interrupt_handles_[0] readable\n");
+ HandleInterruptFd();
+ } else {
+ LOG_INFO("HandleEvents interrupt_handles_[0] not readable\n");
+ }
}
@@ -120,28 +274,30 @@
while (!handler_impl->shutdown_) {
int64_t millis = handler_impl->GetTimeout();
ASSERT((millis == kInfinityTimeout) || (millis >= 0));
-
mx_time_t timeout =
millis * kMicrosecondsPerMillisecond * kNanosecondsPerMicrosecond;
- mx_signals_state_t signals_state;
- mx_status_t status = mx_handle_wait_one(
- handler_impl->interrupt_handles_[0],
- MX_SIGNAL_READABLE | MX_SIGNAL_PEER_CLOSED,
+ const MagentaWaitManyInfo& info = handler_impl->info();
+ uint32_t result_index;
+ LOG_INFO("mx_handle_wait_many(%ld, %p, %p, %lld, %p, %p)\n",
+ info.size(), info.handles(), info.signals(), timeout, &result_index,
+ info.signals_states());
+ mx_status_t status = mx_handle_wait_many(
+ info.size(),
+ info.handles(),
+ info.signals(),
timeout,
- &signals_state);
+ &result_index,
+ info.signals_states());
if ((status != NO_ERROR) && (status != ERR_TIMED_OUT)) {
- FATAL1("mx_handle_wait_one failed: %s\n", mx_status_get_string(status));
+ FATAL1("mx_handle_wait_many failed: %s\n", mx_status_get_string(status));
} else {
+ LOG_INFO("mx_handle_wait_many returned: %ld\n", status);
handler_impl->HandleTimeout();
- if ((signals_state.satisfied & MX_SIGNAL_READABLE) != 0) {
- handler_impl->HandleEvents();
- }
- if ((signals_state.satisfied & MX_SIGNAL_PEER_CLOSED) != 0) {
- FATAL("EventHandlerImplementation::Poll: Unexpected peer closed\n");
- }
+ handler_impl->HandleEvents();
}
}
handler->NotifyShutdownDone();
+ LOG_INFO("EventHandlerImplementation notifying about shutdown\n");
}
diff --git a/runtime/bin/eventhandler_fuchsia.h b/runtime/bin/eventhandler_fuchsia.h
index 0130992..b168c62 100644
--- a/runtime/bin/eventhandler_fuchsia.h
+++ b/runtime/bin/eventhandler_fuchsia.h
@@ -9,11 +9,82 @@
#error Do not include eventhandler_fuchsia.h directly; use eventhandler.h instead.
#endif
+#include <errno.h>
#include <magenta/syscalls.h>
+#include "platform/signal_blocker.h"
+
namespace dart {
namespace bin {
+class DescriptorInfo : public DescriptorInfoBase {
+ public:
+ explicit DescriptorInfo(intptr_t fd) : DescriptorInfoBase(fd) { }
+
+ virtual ~DescriptorInfo() { }
+
+ virtual void Close() {
+ VOID_TEMP_FAILURE_RETRY(close(fd_));
+ fd_ = -1;
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(DescriptorInfo);
+};
+
+class DescriptorInfoSingle
+ : public DescriptorInfoSingleMixin<DescriptorInfo> {
+ public:
+ explicit DescriptorInfoSingle(intptr_t fd)
+ : DescriptorInfoSingleMixin(fd, false) {}
+ virtual ~DescriptorInfoSingle() {}
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(DescriptorInfoSingle);
+};
+
+class DescriptorInfoMultiple
+ : public DescriptorInfoMultipleMixin<DescriptorInfo> {
+ public:
+ explicit DescriptorInfoMultiple(intptr_t fd)
+ : DescriptorInfoMultipleMixin(fd, false) {}
+ virtual ~DescriptorInfoMultiple() {}
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(DescriptorInfoMultiple);
+};
+
+// Information needed to call mx_handle_wait_many(), and to handle events.
+class MagentaWaitManyInfo {
+ public:
+ MagentaWaitManyInfo();
+ ~MagentaWaitManyInfo();
+
+ intptr_t capacity() const { return capacity_; }
+ intptr_t size() const { return size_; }
+ DescriptorInfo** descriptor_infos() const { return descriptor_infos_; }
+ mx_handle_t* handles() const { return handles_; }
+ mx_signals_t* signals() const { return signals_; }
+ mx_signals_state_t* signals_states() const { return signals_states_; }
+
+ void AddHandle(mx_handle_t handle, mx_signals_t signals, DescriptorInfo* di);
+ void RemoveHandle(mx_handle_t handle);
+
+ private:
+ static const intptr_t kInitialCapacity = 32;
+
+ void GrowArraysIfNeeded(intptr_t desired_size);
+
+ intptr_t capacity_;
+ intptr_t size_;
+ DescriptorInfo** descriptor_infos_;
+ mx_handle_t* handles_;
+ mx_signals_t* signals_;
+ mx_signals_state_t* signals_states_;
+
+ DISALLOW_COPY_AND_ASSIGN(MagentaWaitManyInfo);
+};
+
class EventHandlerImplementation {
public:
EventHandlerImplementation();
@@ -23,6 +94,8 @@
void Start(EventHandler* handler);
void Shutdown();
+ const MagentaWaitManyInfo& info() const { return info_; }
+
private:
int64_t GetTimeout() const;
void HandleEvents();
@@ -35,6 +108,8 @@
bool shutdown_;
mx_handle_t interrupt_handles_[2];
+ MagentaWaitManyInfo info_;
+
DISALLOW_COPY_AND_ASSIGN(EventHandlerImplementation);
};
diff --git a/runtime/bin/file.cc b/runtime/bin/file.cc
index a3dcd7f..828db76 100644
--- a/runtime/bin/file.cc
+++ b/runtime/bin/file.cc
@@ -92,7 +92,7 @@
// reading. This is to prevent the opening of directories as
// files. Directories can be opened for reading using the posix
// 'open' call.
- File* file = File::ScopedOpen(filename, file_mode);
+ File* file = File::Open(filename, file_mode);
if (file != NULL) {
Dart_SetReturnValue(args,
Dart_NewInteger(reinterpret_cast<intptr_t>(file)));
@@ -677,7 +677,7 @@
File::DartFileOpenMode dart_file_mode =
static_cast<File::DartFileOpenMode>(mode.Value());
File::FileOpenMode file_mode = File::DartModeToFileMode(dart_file_mode);
- file = File::ScopedOpen(filename.CString(), file_mode);
+ file = File::Open(filename.CString(), file_mode);
if (file != NULL) {
return new CObjectIntptr(
CObject::NewIntptr(reinterpret_cast<intptr_t>(file)));
diff --git a/runtime/bin/file.h b/runtime/bin/file.h
index cef6f0a..aa37ba5 100644
--- a/runtime/bin/file.h
+++ b/runtime/bin/file.h
@@ -157,15 +157,8 @@
// reading and writing. If mode contains kWrite and the file does
// not exist the file is created. The file is truncated to length 0 if
// mode contains kTruncate. Assumes we are in an API scope.
- static File* ScopedOpen(const char* path, FileOpenMode mode);
-
- // Like ScopedOpen(), but no API scope is needed.
static File* Open(const char* path, FileOpenMode mode);
- // Caution! On Windows, the static functions below may call
- // Dart_ScopeAllocate() to do string conversions! If you call these functions
- // without a scope, they will fail on Windows!
-
// Create a file object for the specified stdio file descriptor
// (stdin, stout or stderr).
static File* OpenStdio(int fd);
@@ -181,15 +174,17 @@
static int64_t LengthFromPath(const char* path);
static void Stat(const char* path, int64_t* data);
static time_t LastModified(const char* path);
- static const char* LinkTarget(const char* pathname);
static bool IsAbsolutePath(const char* path);
- static const char* GetCanonicalPath(const char* path);
static const char* PathSeparator();
static const char* StringEscapedPathSeparator();
static Type GetType(const char* path, bool follow_links);
static Identical AreIdentical(const char* file_1, const char* file_2);
static StdioHandleType GetStdioHandleType(int fd);
+ // LinkTarget and GetCanonicalPath may call Dart_ScopeAllocate.
+ static const char* LinkTarget(const char* pathname);
+ static const char* GetCanonicalPath(const char* path);
+
static FileOpenMode DartModeToFileMode(DartFileOpenMode mode);
static CObject* ExistsRequest(const CObjectArray& request);
diff --git a/runtime/bin/file_android.cc b/runtime/bin/file_android.cc
index a139876..ea512ad 100644
--- a/runtime/bin/file_android.cc
+++ b/runtime/bin/file_android.cc
@@ -183,7 +183,7 @@
}
-File* File::ScopedOpen(const char* name, FileOpenMode mode) {
+File* File::Open(const char* name, FileOpenMode mode) {
// Report errors for non-regular files.
struct stat st;
if (NO_RETRY_EXPECTED(stat(name, &st)) == 0) {
@@ -220,12 +220,6 @@
}
-File* File::Open(const char* path, FileOpenMode mode) {
- // ScopedOpen doesn't actually need a scope.
- return ScopedOpen(path, mode);
-}
-
-
File* File::OpenStdio(int fd) {
return ((fd < 0) || (2 < fd)) ? NULL : new File(new FileHandle(fd));
}
diff --git a/runtime/bin/file_fuchsia.cc b/runtime/bin/file_fuchsia.cc
index da22733..ae42333 100644
--- a/runtime/bin/file_fuchsia.cc
+++ b/runtime/bin/file_fuchsia.cc
@@ -164,7 +164,7 @@
}
-File* File::ScopedOpen(const char* name, FileOpenMode mode) {
+File* File::Open(const char* name, FileOpenMode mode) {
// Report errors for non-regular files.
struct stat st;
if (NO_RETRY_EXPECTED(stat(name, &st)) == 0) {
@@ -201,12 +201,6 @@
}
-File* File::Open(const char* path, FileOpenMode mode) {
- // ScopedOpen doesn't actually need a scope.
- return ScopedOpen(path, mode);
-}
-
-
File* File::OpenStdio(int fd) {
return ((fd < 0) || (2 < fd)) ? NULL : new File(new FileHandle(fd));
}
diff --git a/runtime/bin/file_linux.cc b/runtime/bin/file_linux.cc
index e6b27f8..aeba5c8 100644
--- a/runtime/bin/file_linux.cc
+++ b/runtime/bin/file_linux.cc
@@ -182,7 +182,7 @@
}
-File* File::ScopedOpen(const char* name, FileOpenMode mode) {
+File* File::Open(const char* name, FileOpenMode mode) {
// Report errors for non-regular files.
struct stat64 st;
if (TEMP_FAILURE_RETRY(stat64(name, &st)) == 0) {
@@ -220,12 +220,6 @@
}
-File* File::Open(const char* path, FileOpenMode mode) {
- // ScopedOpen doesn't actually need a scope.
- return ScopedOpen(path, mode);
-}
-
-
File* File::OpenStdio(int fd) {
return ((fd < 0) || (2 < fd)) ? NULL : new File(new FileHandle(fd));
}
diff --git a/runtime/bin/file_macos.cc b/runtime/bin/file_macos.cc
index 0720b6f..fe34eb7 100644
--- a/runtime/bin/file_macos.cc
+++ b/runtime/bin/file_macos.cc
@@ -185,7 +185,7 @@
}
-File* File::ScopedOpen(const char* name, FileOpenMode mode) {
+File* File::Open(const char* name, FileOpenMode mode) {
// Report errors for non-regular files.
struct stat st;
if (NO_RETRY_EXPECTED(stat(name, &st)) == 0) {
@@ -223,12 +223,6 @@
}
-File* File::Open(const char* path, FileOpenMode mode) {
- // ScopedOpen doesn't actually need a scope.
- return ScopedOpen(path, mode);
-}
-
-
File* File::OpenStdio(int fd) {
return ((fd < 0) || (2 < fd)) ? NULL : new File(new FileHandle(fd));
}
diff --git a/runtime/bin/file_system_watcher_win.cc b/runtime/bin/file_system_watcher_win.cc
index 698b049..ced2cef 100644
--- a/runtime/bin/file_system_watcher_win.cc
+++ b/runtime/bin/file_system_watcher_win.cc
@@ -40,8 +40,8 @@
int events,
bool recursive) {
USE(id);
- const wchar_t* name = StringUtilsWin::Utf8ToWide(path);
- HANDLE dir = CreateFileW(name,
+ Utf8ToWideScope name(path);
+ HANDLE dir = CreateFileW(name.wide(),
FILE_LIST_DIRECTORY,
FILE_SHARE_READ |
FILE_SHARE_WRITE |
diff --git a/runtime/bin/file_win.cc b/runtime/bin/file_win.cc
index d1e7719..fc72a78 100644
--- a/runtime/bin/file_win.cc
+++ b/runtime/bin/file_win.cc
@@ -233,21 +233,9 @@
}
-File* File::ScopedOpen(const char* name, FileOpenMode mode) {
- const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
- return FileOpenW(system_name, mode);
-}
-
-
File* File::Open(const char* path, FileOpenMode mode) {
- int path_len = MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0);
- wchar_t* system_name = new wchar_t[path_len];
- if (system_name == NULL) {
- return NULL;
- }
- MultiByteToWideChar(CP_UTF8, 0, path, -1, system_name, path_len);
- File* file = FileOpenW(system_name, mode);
- delete[] system_name;
+ Utf8ToWideScope system_name(path);
+ File* file = FileOpenW(system_name.wide(), mode);
return file;
}
@@ -270,8 +258,8 @@
bool File::Exists(const char* name) {
struct __stat64 st;
- const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
- bool stat_status = _wstat64(system_name, &st);
+ Utf8ToWideScope system_name(name);
+ bool stat_status = _wstat64(system_name.wide(), &st);
if (stat_status == 0) {
return ((st.st_mode & S_IFMT) == S_IFREG);
} else {
@@ -281,8 +269,8 @@
bool File::Create(const char* name) {
- const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
- int fd = _wopen(system_name, O_RDONLY | O_CREAT, 0666);
+ Utf8ToWideScope system_name(name);
+ int fd = _wopen(system_name.wide(), O_RDONLY | O_CREAT, 0666);
if (fd < 0) {
return false;
}
@@ -326,17 +314,17 @@
bool File::CreateLink(const char* utf8_name, const char* utf8_target) {
- const wchar_t* name = StringUtilsWin::Utf8ToWide(utf8_name);
- int create_status = CreateDirectoryW(name, NULL);
+ Utf8ToWideScope name(utf8_name);
+ int create_status = CreateDirectoryW(name.wide(), NULL);
// If the directory already existed, treat it as a success.
if ((create_status == 0) &&
((GetLastError() != ERROR_ALREADY_EXISTS) ||
- ((GetFileAttributesW(name) & FILE_ATTRIBUTE_DIRECTORY) != 0))) {
+ ((GetFileAttributesW(name.wide()) & FILE_ATTRIBUTE_DIRECTORY) != 0))) {
return false;
}
HANDLE dir_handle = CreateFileW(
- name,
+ name.wide(),
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL,
@@ -347,8 +335,8 @@
return false;
}
- const wchar_t* target = StringUtilsWin::Utf8ToWide(utf8_target);
- int target_len = wcslen(target);
+ Utf8ToWideScope target(utf8_target);
+ int target_len = wcslen(target.wide());
if (target_len > MAX_PATH - 1) {
CloseHandle(dir_handle);
return false;
@@ -357,13 +345,13 @@
int reparse_data_buffer_size =
sizeof REPARSE_DATA_BUFFER + 2 * MAX_PATH * sizeof WCHAR;
REPARSE_DATA_BUFFER* reparse_data_buffer =
- reinterpret_cast<REPARSE_DATA_BUFFER*>(Dart_ScopeAllocate(
- reparse_data_buffer_size));
+ reinterpret_cast<REPARSE_DATA_BUFFER*>(malloc(reparse_data_buffer_size));
reparse_data_buffer->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
- wcscpy(reparse_data_buffer->MountPointReparseBuffer.PathBuffer, target);
+ wcscpy(reparse_data_buffer->MountPointReparseBuffer.PathBuffer,
+ target.wide());
wcscpy(
reparse_data_buffer->MountPointReparseBuffer.PathBuffer + target_len + 1,
- target);
+ target.wide());
reparse_data_buffer->MountPointReparseBuffer.SubstituteNameOffset = 0;
reparse_data_buffer->MountPointReparseBuffer.SubstituteNameLength =
target_len * sizeof WCHAR;
@@ -383,6 +371,7 @@
0,
&dummy_received_bytes,
NULL);
+ free(reparse_data_buffer);
if (CloseHandle(dir_handle) == 0) {
return false;
}
@@ -391,20 +380,20 @@
bool File::Delete(const char* name) {
- const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
- int status = _wremove(system_name);
+ Utf8ToWideScope system_name(name);
+ int status = _wremove(system_name.wide());
return status != -1;
}
bool File::DeleteLink(const char* name) {
- const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
+ Utf8ToWideScope system_name(name);
bool result = false;
- DWORD attributes = GetFileAttributesW(system_name);
+ DWORD attributes = GetFileAttributesW(system_name.wide());
if ((attributes != INVALID_FILE_ATTRIBUTES) &&
(attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
// It's a junction(link), delete it.
- result = (RemoveDirectoryW(system_name) != 0);
+ result = (RemoveDirectoryW(system_name.wide()) != 0);
} else {
SetLastError(ERROR_NOT_A_REPARSE_POINT);
}
@@ -415,11 +404,11 @@
bool File::Rename(const char* old_path, const char* new_path) {
File::Type type = GetType(old_path, false);
if (type == kIsFile) {
- const wchar_t* system_old_path = StringUtilsWin::Utf8ToWide(old_path);
- const wchar_t* system_new_path = StringUtilsWin::Utf8ToWide(new_path);
+ Utf8ToWideScope system_old_path(old_path);
+ Utf8ToWideScope system_new_path(new_path);
DWORD flags = MOVEFILE_WRITE_THROUGH | MOVEFILE_REPLACE_EXISTING;
int move_status =
- MoveFileExW(system_old_path, system_new_path, flags);
+ MoveFileExW(system_old_path.wide(), system_new_path.wide(), flags);
return (move_status != 0);
} else {
SetLastError(ERROR_FILE_NOT_FOUND);
@@ -431,11 +420,11 @@
bool File::RenameLink(const char* old_path, const char* new_path) {
File::Type type = GetType(old_path, false);
if (type == kIsLink) {
- const wchar_t* system_old_path = StringUtilsWin::Utf8ToWide(old_path);
- const wchar_t* system_new_path = StringUtilsWin::Utf8ToWide(new_path);
+ Utf8ToWideScope system_old_path(old_path);
+ Utf8ToWideScope system_new_path(new_path);
DWORD flags = MOVEFILE_WRITE_THROUGH | MOVEFILE_REPLACE_EXISTING;
int move_status =
- MoveFileExW(system_old_path, system_new_path, flags);
+ MoveFileExW(system_old_path.wide(), system_new_path.wide(), flags);
return (move_status != 0);
} else {
SetLastError(ERROR_FILE_NOT_FOUND);
@@ -447,10 +436,10 @@
bool File::Copy(const char* old_path, const char* new_path) {
File::Type type = GetType(old_path, false);
if (type == kIsFile) {
- const wchar_t* system_old_path = StringUtilsWin::Utf8ToWide(old_path);
- const wchar_t* system_new_path = StringUtilsWin::Utf8ToWide(new_path);
- bool success = CopyFileExW(system_old_path,
- system_new_path,
+ Utf8ToWideScope system_old_path(old_path);
+ Utf8ToWideScope system_new_path(new_path);
+ bool success = CopyFileExW(system_old_path.wide(),
+ system_new_path.wide(),
NULL,
NULL,
NULL,
@@ -465,8 +454,8 @@
int64_t File::LengthFromPath(const char* name) {
struct __stat64 st;
- const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
- int stat_status = _wstat64(system_name, &st);
+ Utf8ToWideScope system_name(name);
+ int stat_status = _wstat64(system_name.wide(), &st);
if (stat_status == 0) {
return st.st_size;
}
@@ -565,8 +554,8 @@
data[kType] = type;
if (type != kDoesNotExist) {
struct _stat64 st;
- const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
- int stat_status = _wstat64(system_name, &st);
+ Utf8ToWideScope system_name(name);
+ int stat_status = _wstat64(system_name.wide(), &st);
if (stat_status == 0) {
data[kCreatedTime] = st.st_ctime * 1000;
data[kModifiedTime] = st.st_mtime * 1000;
@@ -582,8 +571,8 @@
time_t File::LastModified(const char* name) {
struct __stat64 st;
- const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
- int stat_status = _wstat64(system_name, &st);
+ Utf8ToWideScope system_name(name);
+ int stat_status = _wstat64(system_name.wide(), &st);
if (stat_status == 0) {
return st.st_mtime;
}
@@ -603,9 +592,9 @@
const char* File::GetCanonicalPath(const char* pathname) {
- const wchar_t* system_name = StringUtilsWin::Utf8ToWide(pathname);
+ Utf8ToWideScope system_name(pathname);
HANDLE file_handle = CreateFileW(
- system_name,
+ system_name.wide(),
0,
FILE_SHARE_READ,
NULL,
@@ -639,7 +628,7 @@
if ((result_size < MAX_PATH - 1 + 4) &&
(result_size > 4) &&
(wcsncmp(path, L"\\\\?\\", 4) == 0) &&
- (wcsncmp(system_name, L"\\\\?\\", 4) != 0)) {
+ (wcsncmp(system_name.wide(), L"\\\\?\\", 4) != 0)) {
result = StringUtilsWin::WideToUtf8(path + 4);
} else {
result = StringUtilsWin::WideToUtf8(path);
@@ -670,19 +659,15 @@
File::Type File::GetType(const char* pathname, bool follow_links) {
// Convert to wchar_t string.
- int name_len = MultiByteToWideChar(CP_UTF8, 0, pathname, -1, NULL, 0);
- wchar_t* name;
- name = new wchar_t[name_len];
- MultiByteToWideChar(CP_UTF8, 0, pathname, -1, name, name_len);
-
- DWORD attributes = GetFileAttributesW(name);
+ Utf8ToWideScope name(pathname);
+ DWORD attributes = GetFileAttributesW(name.wide());
File::Type result = kIsFile;
if (attributes == INVALID_FILE_ATTRIBUTES) {
result = kDoesNotExist;
} else if ((attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
if (follow_links) {
HANDLE dir_handle = CreateFileW(
- name,
+ name.wide(),
0,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL,
@@ -701,7 +686,6 @@
} else if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
result = kIsDirectory;
}
- delete[] name;
return result;
}
@@ -710,9 +694,9 @@
BY_HANDLE_FILE_INFORMATION file_info[2];
const char* file_names[2] = { file_1, file_2 };
for (int i = 0; i < 2; ++i) {
- const wchar_t* wide_name = StringUtilsWin::Utf8ToWide(file_names[i]);
+ Utf8ToWideScope wide_name(file_names[i]);
HANDLE file_handle = CreateFileW(
- wide_name,
+ wide_name.wide(),
0,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL,
diff --git a/runtime/bin/gen_snapshot.cc b/runtime/bin/gen_snapshot.cc
index cf1ba38..05452ae 100644
--- a/runtime/bin/gen_snapshot.cc
+++ b/runtime/bin/gen_snapshot.cc
@@ -382,7 +382,12 @@
const uint8_t* buffer,
const intptr_t size) {
File* file = File::Open(filename, File::kWriteTruncate);
- ASSERT(file != NULL);
+ if (file == NULL) {
+ Log::PrintErr("Error: Unable to write snapshot file: %s\n\n", filename);
+ Dart_ExitScope();
+ Dart_ShutdownIsolate();
+ exit(kErrorExitCode);
+ }
if (!file->WriteFully(buffer, size)) {
Log::PrintErr("Error: Failed to write snapshot file.\n\n");
}
diff --git a/runtime/bin/log_fuchsia.cc b/runtime/bin/log_fuchsia.cc
index 0c1f7af..b3f9d1d 100644
--- a/runtime/bin/log_fuchsia.cc
+++ b/runtime/bin/log_fuchsia.cc
@@ -19,7 +19,7 @@
void Log::VPrintErr(const char* format, va_list args) {
vfprintf(stderr, format, args);
- fflush(stdout);
+ fflush(stderr);
}
} // namespace bin
diff --git a/runtime/bin/main.cc b/runtime/bin/main.cc
index 4126cbc..c953b62 100644
--- a/runtime/bin/main.cc
+++ b/runtime/bin/main.cc
@@ -963,6 +963,13 @@
" --warn-on-pause-with-no-debugger\n"
" This set is subject to change.\n"
" Please see these options (--help --verbose) for further documentation.\n"
+"--snapshot-kind=<snapsot_kind>\n"
+"--snapshot=<file_name>\n"
+" These snapshot options are used to generate a snapshot of the loaded\n"
+" Dart script:\n"
+" <snapshot-kind> controls the kind of snapshot, it could be\n"
+" script(default), app-aot or app-jit\n"
+" <file_name> specifies the file into which the snapshot is written\n"
"--version\n"
" Print the VM version.\n");
} else {
@@ -987,12 +994,16 @@
" --warn-on-pause-with-no-debugger\n"
" This set is subject to change.\n"
" Please see these options for further documentation.\n"
+"--snapshot-kind=<snapsot_kind>\n"
+"--snapshot=<file_name>\n"
+" These snapshot options are used to generate a snapshot of the loaded\n"
+" Dart script:\n"
+" <snapshot-kind> controls the kind of snapshot, it could be\n"
+" script(default), app-aot or app-jit\n"
+" <file_name> specifies the file into which the snapshot is written\n"
"--version\n"
" Print the VM version.\n"
"\n"
-"--snapshot=<file_name>\n"
-" loads Dart script and generates a snapshot in the specified file\n"
-"\n"
"--trace-loading\n"
" enables tracing of library and script loading\n"
"\n"
diff --git a/runtime/bin/run_vm_tests_fuchsia.cc b/runtime/bin/run_vm_tests_fuchsia.cc
index a974860..db8baf2 100644
--- a/runtime/bin/run_vm_tests_fuchsia.cc
+++ b/runtime/bin/run_vm_tests_fuchsia.cc
@@ -98,17 +98,12 @@
"Fail2",
"AllocGeneric_Overflow",
"CodeImmutability",
+ // Assumes initial thread's stack is the same size as spawned thread stacks.
+ "StackOverflowStacktraceInfo",
};
// Bugs to fix, or things that are not yet implemented.
const char* kBugs[] = {
- // Needs NativeSymbolResolver
- "Service_PersistentHandles",
- // Needs lstat
- "DirectoryCreateTemp",
- "DirectoryCreateDelete",
- // Needs rename
- "DirectoryRename",
// Needs read of RSS.
"InitialRSS",
};
@@ -346,7 +341,7 @@
static void run_all_tests(runner_args_t* args) {
const intptr_t num_cpus = sysconf(_SC_NPROCESSORS_CONF);
pthread_t* threads =
- reinterpret_cast<pthread_t*>(malloc(num_cpus * sizeof(pthread_t)));
+ reinterpret_cast<pthread_t*>(malloc(num_cpus * sizeof(pthread_t)));
for (int i = 0; i < num_cpus; i++) {
pthread_create(&threads[i], NULL, test_runner_thread, args);
}
diff --git a/runtime/bin/socket_win.cc b/runtime/bin/socket_win.cc
index f76f764..1dce52e 100644
--- a/runtime/bin/socket_win.cc
+++ b/runtime/bin/socket_win.cc
@@ -370,12 +370,12 @@
bool Socket::ParseAddress(int type, const char* address, RawAddr* addr) {
int result;
- const wchar_t* system_address = StringUtilsWin::Utf8ToWide(address);
+ Utf8ToWideScope system_address(address);
if (type == SocketAddress::TYPE_IPV4) {
- result = InetPton(AF_INET, system_address, &addr->in.sin_addr);
+ result = InetPton(AF_INET, system_address.wide(), &addr->in.sin_addr);
} else {
ASSERT(type == SocketAddress::TYPE_IPV6);
- result = InetPton(AF_INET6, system_address, &addr->in6.sin6_addr);
+ result = InetPton(AF_INET6, system_address.wide(), &addr->in6.sin6_addr);
}
return result == 1;
}
diff --git a/runtime/bin/utils_win.h b/runtime/bin/utils_win.h
index fe0fa5c..3e7fa4c 100644
--- a/runtime/bin/utils_win.h
+++ b/runtime/bin/utils_win.h
@@ -37,6 +37,61 @@
DISALLOW_IMPLICIT_CONSTRUCTORS(StringUtilsWin);
};
+// These scopes provide strings converted as indicated by the scope names.
+// The provided strings are allocated with 'new' and have the same lifetime as
+// the scope.
+class WideToUtf8Scope {
+ public:
+ explicit WideToUtf8Scope(const wchar_t* wide) {
+ intptr_t utf8_len = WideCharToMultiByte(
+ CP_UTF8, 0, wide, -1, NULL, 0, NULL, NULL);
+ char* utf8 = new char[utf8_len];
+ WideCharToMultiByte(CP_UTF8, 0, wide, -1, utf8, utf8_len, NULL, NULL);
+ length_ = utf8_len;
+ utf8_ = utf8;
+ }
+
+ ~WideToUtf8Scope() {
+ delete[] utf8_;
+ utf8_ = NULL;
+ }
+
+ char* utf8() const { return utf8_; }
+ intptr_t length() const { return length_; }
+
+ private:
+ intptr_t length_;
+ char* utf8_;
+
+ DISALLOW_ALLOCATION();
+ DISALLOW_IMPLICIT_CONSTRUCTORS(WideToUtf8Scope);
+};
+
+class Utf8ToWideScope {
+ public:
+ explicit Utf8ToWideScope(const char* utf8) {
+ int wide_len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
+ wchar_t* wide = new wchar_t[wide_len];
+ MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wide, wide_len);
+ length_ = wide_len;
+ wide_ = wide;
+ }
+
+ ~Utf8ToWideScope() {
+ delete[] wide_;
+ }
+
+ wchar_t* wide() const { return wide_; }
+ intptr_t length() const { return length_; }
+
+ private:
+ intptr_t length_;
+ wchar_t* wide_;
+
+ DISALLOW_ALLOCATION();
+ DISALLOW_IMPLICIT_CONSTRUCTORS(Utf8ToWideScope);
+};
+
} // namespace bin
} // namespace dart
diff --git a/runtime/platform/utils_fuchsia.h b/runtime/platform/utils_fuchsia.h
index 4e8c4e9..575c3db 100644
--- a/runtime/platform/utils_fuchsia.h
+++ b/runtime/platform/utils_fuchsia.h
@@ -62,7 +62,9 @@
inline char* Utils::StrError(int err, char* buffer, size_t bufsize) {
- snprintf(buffer, bufsize, "errno = %d", err);
+ if (strerror_r(err, buffer, bufsize) != 0) {
+ snprintf(buffer, bufsize, "%s", "strerror_r failed");
+ }
return buffer;
}
diff --git a/runtime/vm/dart.cc b/runtime/vm/dart.cc
index b4534c9..413dad3 100644
--- a/runtime/vm/dart.cc
+++ b/runtime/vm/dart.cc
@@ -270,6 +270,8 @@
} else {
#if defined(DART_PRECOMPILED_RUNTIME)
return strdup("Precompiled runtime requires a precompiled snapshot");
+#elif !defined(DART_NO_SNAPSHOT)
+ return strdup("Missing vm isolate snapshot");
#else
snapshot_kind_ = Snapshot::kNone;
StubCode::InitOnce();
@@ -522,7 +524,7 @@
const Snapshot* snapshot = Snapshot::SetupFromBuffer(snapshot_buffer);
if (snapshot == NULL) {
const String& message = String::Handle(
- String::New("Invalid snapshot."));
+ String::New("Invalid snapshot"));
return ApiError::New(message);
}
ASSERT(Snapshot::IsFull(snapshot->kind()));
@@ -551,7 +553,11 @@
MegamorphicCacheTable::PrintSizes(I);
}
} else {
- ASSERT(snapshot_kind_ == Snapshot::kNone);
+ if (snapshot_kind_ != Snapshot::kNone) {
+ const String& message = String::Handle(
+ String::New("Missing isolate snapshot"));
+ return ApiError::New(message);
+ }
}
Object::VerifyBuiltinVtables();
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
index 7bef09e..6d485a5 100644
--- a/runtime/vm/dart_api_impl.cc
+++ b/runtime/vm/dart_api_impl.cc
@@ -113,6 +113,11 @@
void VisitObject(RawObject* obj) {
if (obj->IsFunction()) {
funcHandle_ ^= obj;
+ if (funcHandle_.IsSignatureFunction()) {
+ // TODO(27606): Remove signature function case.
+ return;
+ }
+
classHandle_ ^= funcHandle_.Owner();
// Verify that the result type of a function is canonical or a
// TypeParameter.
diff --git a/runtime/vm/native_symbol_fuchsia.cc b/runtime/vm/native_symbol_fuchsia.cc
index cb0f02a..084c00b 100644
--- a/runtime/vm/native_symbol_fuchsia.cc
+++ b/runtime/vm/native_symbol_fuchsia.cc
@@ -2,33 +2,41 @@
// 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.
-#include "vm/globals.h"
+#include "platform/globals.h"
#if defined(TARGET_OS_FUCHSIA)
#include "vm/native_symbol.h"
-#include "platform/assert.h"
+#include <dlfcn.h> // NOLINT
namespace dart {
void NativeSymbolResolver::InitOnce() {
- UNIMPLEMENTED();
}
void NativeSymbolResolver::ShutdownOnce() {
- UNIMPLEMENTED();
}
char* NativeSymbolResolver::LookupSymbolName(uintptr_t pc, uintptr_t* start) {
- UNIMPLEMENTED();
- return NULL;
+ Dl_info info;
+ int r = dladdr(reinterpret_cast<void*>(pc), &info);
+ if (r == 0) {
+ return NULL;
+ }
+ if (info.dli_sname == NULL) {
+ return NULL;
+ }
+ if (start != NULL) {
+ *start = reinterpret_cast<uintptr_t>(info.dli_saddr);
+ }
+ return strdup(info.dli_sname);
}
void NativeSymbolResolver::FreeSymbolName(char* name) {
- UNIMPLEMENTED();
+ free(name);
}
} // namespace dart
diff --git a/runtime/vm/os_fuchsia.cc b/runtime/vm/os_fuchsia.cc
index 48181f7..f9049265 100644
--- a/runtime/vm/os_fuchsia.cc
+++ b/runtime/vm/os_fuchsia.cc
@@ -33,21 +33,39 @@
}
+static bool LocalTime(int64_t seconds_since_epoch, tm* tm_result) {
+ time_t seconds = static_cast<time_t>(seconds_since_epoch);
+ if (seconds != seconds_since_epoch) {
+ return false;
+ }
+ struct tm* error_code = localtime_r(&seconds, tm_result);
+ return error_code != NULL;
+}
+
+
const char* OS::GetTimeZoneName(int64_t seconds_since_epoch) {
- UNIMPLEMENTED();
- return "";
+ tm decomposed;
+ bool succeeded = LocalTime(seconds_since_epoch, &decomposed);
+ // If unsuccessful, return an empty string like V8 does.
+ return (succeeded && (decomposed.tm_zone != NULL)) ? decomposed.tm_zone : "";
}
int OS::GetTimeZoneOffsetInSeconds(int64_t seconds_since_epoch) {
- UNIMPLEMENTED();
- return 0;
+ tm decomposed;
+ bool succeeded = LocalTime(seconds_since_epoch, &decomposed);
+ // Even if the offset was 24 hours it would still easily fit into 32 bits.
+ // If unsuccessful, return zero like V8 does.
+ return succeeded ? static_cast<int>(decomposed.tm_gmtoff) : 0;
}
int OS::GetLocalTimeZoneAdjustmentInSeconds() {
- UNIMPLEMENTED();
- return 0;
+ // TODO(floitsch): avoid excessive calls to tzset?
+ tzset();
+ // Even if the offset was 24 hours it would still easily fit into 32 bits.
+ // Note that Unix and Dart disagree on the sign.
+ return static_cast<int>(-timezone);
}
diff --git a/sdk/lib/core/set.dart b/sdk/lib/core/set.dart
index 7e2508c..a4d7ed7 100644
--- a/sdk/lib/core/set.dart
+++ b/sdk/lib/core/set.dart
@@ -185,7 +185,7 @@
* That is, the returned set contains all the elements of this [Set] that
* are not elements of [other] according to `other.contains`.
*/
- Set<E> difference(Set<E> other);
+ Set<E> difference(Set<Object> other);
/**
* Removes all elements in the set.
diff --git a/tests/co19/co19-runtime.status b/tests/co19/co19-runtime.status
index d78deae..d4ee097 100644
--- a/tests/co19/co19-runtime.status
+++ b/tests/co19/co19-runtime.status
@@ -26,20 +26,14 @@
Language/Statements/Assert/type_t02: skip # co19 issue 734
Language/Statements/Assert/type_t05: skip # co19 issue 734
-
-LibTest/core/DateTime/DateTime.now_A01_t02: Pass, Fail # co19 issue 709
-
-LibTest/isolate/Isolate/spawnUri_A01_t02: Skip # Issue 15974
-LibTest/isolate/Isolate/spawnUri_A01_t03: Skip # Issue 15974
LibTest/isolate/Isolate/spawnUri_A02_t02: Skip # Issue 15974
LibTest/isolate/Isolate/spawnUri_A02_t03: Skip # Issue 15974
-LibTest/isolate/Isolate/spawnUri_A02_t04: Skip # Issue 15974
LibTest/isolate/Isolate/spawn_A03_t02: Skip # Issue 15974
LibTest/isolate/Isolate/spawn_A04_t01: Skip # Issue 15974
LibTest/isolate/Isolate/spawn_A04_t04: Skip # Issue 15974
LibTest/isolate/Isolate/spawn_A06_t03: Skip # Issue 15974
LibTest/isolate/Isolate/spawn_A06_t05: Skip # Issue 15974
-LibTest/isolate/Isolate/spawn_A04_t03: Pass, RuntimeError # Issue 27202
+LibTest/isolate/Isolate/spawn_A04_t03: Skip # Flaky, Issue 15974
LibTest/core/Symbol/Symbol_A01_t03: RuntimeError # Issue 13596
LibTest/core/Symbol/Symbol_A01_t05: RuntimeError # Issue 13596
@@ -56,9 +50,6 @@
LibTest/core/List/List_class_A01_t02: Pass, Slow
Language/Libraries_and_Scripts/Imports/deferred_import_t02: Crash # Issue 27201
-[ ($runtime == vm || $runtime == dart_precompiled || $runtime == dart_app) && $system == windows ]
-Language/Expressions/Function_Invocation/async_invokation_t04: Pass, RuntimeError # co19 issue 54
-
[ ($runtime == vm || $runtime == dart_precompiled || $runtime == dart_app) && ($arch != x64 && $arch != simarm64 && $arch != arm64 && $arch != simdbc64) ]
LibTest/core/int/operator_left_shift_A01_t02: Fail # co19 issue 129
@@ -78,8 +69,6 @@
LibTest/collection/ListMixin/ListMixin_class_A01_t01: Skip # Timeout
LibTest/collection/ListMixin/ListMixin_class_A01_t02: Skip # Timeout
LibTest/core/Uri/Uri_A06_t03: Skip # Timeout
-LibTest/isolate/Isolate/spawnUri_A01_t06: Pass, Fail # Issue 27378
-LibTest/isolate/Isolate/spawnUri_A01_t07: Pass, Fail # Issue 27378
[ $system == windows ]
LibTest/collection/ListMixin/ListMixin_class_A01_t02: Pass, Slow
@@ -171,7 +160,7 @@
Language/Libraries_and_Scripts/Imports/invalid_uri_deferred_t02: Skip # Eager loading
[ $runtime == dart_precompiled || $runtime == dart_app ]
-LibTest/isolate/Isolate/spawnUri*: Skip # Isolate.spawnUri
+LibTest/isolate/Isolate/spawnUri*: SkipByDesign # Isolate.spawnUri
[ $noopt || $compiler == precompiler ]
LibTest/collection/ListBase/ListBase_class_A01_t02: Pass, Timeout
@@ -184,7 +173,6 @@
Language/Mixins/Mixin_Application/error_t02: Pass
Language/Mixins/declaring_constructor_t01: Pass
-
[ ($arch == simdbc || $arch == simdbc64) && $mode == debug ]
# TODO(vegorov) These tests are very slow on unoptimized SIMDBC
LibTest/collection/ListMixin/ListMixin_class_A01_t02: Timeout
@@ -192,8 +180,6 @@
[ $compiler == precompiler && $runtime == dart_precompiled && $system == android ]
*: Skip # Issue 27294
-LibTest/isolate/*: Skip # Issue #26373
-Language/Expressions/Spawning_an_Isolate/new_isolate_t01: Skip # Issue #26373
LibTest/math/log_A01_t01: RuntimeError # Precision of Math.log (Issue #18998)
Language/Expressions/Object_Identity/double_t02: RuntimeError # Issue #26374
diff --git a/tests/corelib/set_test.dart b/tests/corelib/set_test.dart
index 55e7250..9900bb8 100644
--- a/tests/corelib/set_test.dart
+++ b/tests/corelib/set_test.dart
@@ -166,6 +166,17 @@
}
Expect.isTrue(twice.difference(thrice).difference(twice).isEmpty);
+ // Test Set.difference with non-element type.
+ Set diffSet = create()..addAll([0, 1, 2, 499, 999]);
+ Set<Object> objectSet = new Set<Object>();
+ objectSet.add("foo");
+ objectSet.add(499);
+ Set diffResult = diffSet.difference(objectSet);
+ Expect.equals(4, diffResult.length);
+ for (int value in [0, 1, 2, 999]) {
+ Expect.isTrue(diffResult.contains(value));
+ }
+
// Test Set.addAll.
List list = new List(10);
for (int i = 0; i < 10; i++) {
diff --git a/tests/isolate/isolate.status b/tests/isolate/isolate.status
index 473e036..ffba137 100644
--- a/tests/isolate/isolate.status
+++ b/tests/isolate/isolate.status
@@ -231,9 +231,6 @@
[ $compiler == dart2js && $cps_ir && $checked ]
*: Skip # `assert` not implemented
-[ $compiler == precompiler && $runtime == dart_precompiled && $system == android ]
-*: Skip # Issue #26373
-
[ $hot_reload || $hot_reload_rollback ]
function_send_test: Pass, Fail # Closure identity
message3_test/fun: Pass, Fail # Closure identity
diff --git a/tests/language/language.status b/tests/language/language.status
index 3eb4aba..34791b41 100644
--- a/tests/language/language.status
+++ b/tests/language/language.status
@@ -254,10 +254,6 @@
# The following tests are supposed to fail.
library_env_test/has_mirror_support: RuntimeError, OK
-[ $compiler == precompiler && $runtime == dart_precompiled && $system == android ]
-vm/optimized_guarded_field_isolates_test: Skip # Issue #26373
-issue23244_test: Skip # Issue #26373
-
[ $hot_reload || $hot_reload_rollback ]
static_closure_identical_test: Pass, Fail # Closure identity
cha_deopt1_test: Crash # Requires deferred libraries
diff --git a/tests/standalone/io/http_server_response_test.dart b/tests/standalone/io/http_server_response_test.dart
index 967a508..c3c0afb 100644
--- a/tests/standalone/io/http_server_response_test.dart
+++ b/tests/standalone/io/http_server_response_test.dart
@@ -6,12 +6,18 @@
// VMOptions=--short_socket_read
// VMOptions=--short_socket_write
// VMOptions=--short_socket_read --short_socket_write
+// OtherResources=http_server_response_test.dart
import "package:expect/expect.dart";
import "dart:async";
import "dart:io";
import "dart:typed_data";
+// Platform.script may refer to a AOT or JIT snapshot, which are significantly
+// larger.
+File scriptSource = new File(
+ Platform.script.resolve("http_server_response_test.dart").toFilePath());
+
void testServerRequest(void handler(server, request),
{int bytes,
bool closeClient}) {
@@ -81,7 +87,7 @@
void testResponseAddStream() {
- File file = new File(Platform.script.toFilePath());
+ File file = scriptSource;
int bytes = file.lengthSync();
testServerRequest((server, request) {
@@ -130,7 +136,7 @@
void testResponseAddStreamClosed() {
- File file = new File(Platform.script.toFilePath());
+ File file = scriptSource;
testServerRequest((server, request) {
request.response.addStream(file.openRead())
.then((response) {
@@ -160,7 +166,7 @@
void testResponseAddClosed() {
- File file = new File(Platform.script.toFilePath());
+ File file = scriptSource;
testServerRequest((server, request) {
request.response.add(file.readAsBytesSync());
request.response.close();
diff --git a/tests/standalone/io/pipe_server_test.dart b/tests/standalone/io/pipe_server_test.dart
index 6481a91..f0cba0e 100644
--- a/tests/standalone/io/pipe_server_test.dart
+++ b/tests/standalone/io/pipe_server_test.dart
@@ -2,6 +2,8 @@
// 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.
//
+// OtherResources=readline_test1.dat
+//
// VMOptions=
// VMOptions=--short_socket_read
// VMOptions=--short_socket_write
@@ -18,7 +20,7 @@
String getDataFilename(String path) =>
- new File(path).existsSync() ? path : '../$path';
+ Platform.script.resolve(path).toFilePath();
bool compareFileContent(String fileName1, String fileName2) {
@@ -47,7 +49,7 @@
void connectHandler() {
String srcFileName =
- getDataFilename("tests/standalone/io/readline_test1.dat");
+ getDataFilename("readline_test1.dat");
Stream fileInput = new File(srcFileName).openRead();
fileInput.pipe(_socket).then((_) {
var tempDir = Directory.systemTemp.createTempSync('dart_pipe_server');
diff --git a/tests/standalone/io/stream_pipe_test.dart b/tests/standalone/io/stream_pipe_test.dart
index 2504e77..1945a7b 100644
--- a/tests/standalone/io/stream_pipe_test.dart
+++ b/tests/standalone/io/stream_pipe_test.dart
@@ -2,6 +2,8 @@
// 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.
//
+// OtherResources=readline_test1.dat
+//
// VMOptions=
// VMOptions=--short_socket_read
// VMOptions=--short_socket_write
@@ -15,7 +17,7 @@
// Helper method to be able to run the test from the runtime
// directory, or the top directory.
String getDataFilename(String path) =>
- new File(path).existsSync() ? path : '../$path';
+ Platform.script.resolve(path).toFilePath();
bool compareFileContent(String fileName1,
@@ -64,7 +66,7 @@
asyncStart();
String srcFileName =
- getDataFilename("tests/standalone/io/readline_test1.dat");
+ getDataFilename("readline_test1.dat");
var srcStream = new File(srcFileName).openRead();
var tempDir = Directory.systemTemp.createTempSync('dart_stream_pipe');
@@ -89,7 +91,7 @@
asyncStart();
String srcFileName =
- getDataFilename("tests/standalone/io/readline_test1.dat");
+ getDataFilename("readline_test1.dat");
var srcFile = new File(srcFileName);
var srcStream = srcFile.openRead();
@@ -131,7 +133,7 @@
asyncStart();
String srcFileName =
- getDataFilename("tests/standalone/io/readline_test1.dat");
+ getDataFilename("readline_test1.dat");
var srcFile = new File(srcFileName);
var srcStream = srcFile.openRead();
diff --git a/tests/standalone/standalone.status b/tests/standalone/standalone.status
index cd95358..f145e17 100644
--- a/tests/standalone/standalone.status
+++ b/tests/standalone/standalone.status
@@ -326,6 +326,35 @@
# SIMDBC interpreter doesn't support --no_lazy_dispatchers
no_lazy_dispatchers_test: SkipByDesign
+[ $compiler == precompiler && $runtime == dart_precompiled && $system == android ]
+# Issue 26376
+io/file_system_watcher_test: RuntimeError
+io/uri_platform_test: RuntimeError
+io/resolve_symbolic_links_test: RuntimeError
+io/file_stat_test: RuntimeError
+# Issue #27638
+io/raw_datagram_socket_test: RuntimeError
+io/http_proxy_advanced_test: RuntimeError
+io/regress_21160_test: RuntimeError
+io/secure_multiple_client_server_test: RuntimeError
+io/http_proxy_test: RuntimeError
+io/secure_session_resume_test: RuntimeError
+io/raw_secure_server_socket_test: RuntimeError
+io/raw_secure_server_closing_test: RuntimeError
+io/raw_secure_socket_pause_test: RuntimeError
+io/https_server_test: RuntimeError
+io/secure_server_client_certificate_test: RuntimeError
+io/secure_socket_alpn_test: RuntimeError
+io/secure_bad_certificate_test: RuntimeError
+io/secure_server_socket_test: RuntimeError
+io/secure_client_server_test: RuntimeError
+io/socket_upgrade_to_secure_test: RuntimeError
+io/secure_client_raw_server_test: RuntimeError
+io/secure_socket_test: RuntimeError
+io/raw_secure_socket_test: RuntimeError
+io/https_bad_certificate_test: RuntimeError
+io/secure_server_closing_test: RuntimeError
+
[ $runtime == vm || $runtime == dart_app || $runtime == dart_precompiled ]
deferred_transitive_import_error_test: Skip # Contains intentional errors.
diff --git a/tools/VERSION b/tools/VERSION
index ba2e5eb..8674007 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -28,5 +28,5 @@
MAJOR 1
MINOR 21
PATCH 0
-PRERELEASE 1
+PRERELEASE 2
PRERELEASE_PATCH 0
diff --git a/tools/bots/gn_tests.py b/tools/bots/gn_tests.py
index 877b6dc..cd7ffaa 100644
--- a/tools/bots/gn_tests.py
+++ b/tools/bots/gn_tests.py
@@ -16,7 +16,8 @@
def main(argv):
test_py = os.path.join(DART_ROOT, 'tools', 'test.py')
build_result = subprocess.call(
- ['python', test_py] + ['--builder-tag=no_ipv6'] + argv[1:])
+ ['python', test_py, '--builder-tag=no_ipv6', '--exclude-suite=pkg']
+ + argv[1:])
if build_result != 0:
return build_result
return 0
diff --git a/tools/dart_for_gn.py b/tools/dart_for_gn.py
index 835bbaa..2e6871d 100755
--- a/tools/dart_for_gn.py
+++ b/tools/dart_for_gn.py
@@ -13,12 +13,23 @@
import subprocess
import sys
+def run_command(command):
+ try:
+ subprocess.check_output(command, stderr=subprocess.STDOUT)
+ return 0
+ except subprocess.CalledProcessError as e:
+ return ("Command failed: " + ' '.join(command) + "\n" +
+ "output: " + e.output)
+
def main(argv):
if len(argv) < 2:
print "Requires path to Dart VM binary as first argument"
return -1
- command = argv[1:]
- return subprocess.call(command)
+ result = run_command(argv[1:])
+ if result != 0:
+ print result
+ return -1
+ return 0
if __name__ == '__main__':
sys.exit(main(sys.argv))
diff --git a/utils/analysis_server/BUILD.gn b/utils/analysis_server/BUILD.gn
index 767c81f..032a086 100644
--- a/utils/analysis_server/BUILD.gn
+++ b/utils/analysis_server/BUILD.gn
@@ -6,4 +6,5 @@
application_snapshot("analysis_server") {
main_dart = "../../pkg/analysis_server/bin/server.dart"
+ training_args = [ "--help" ]
}
diff --git a/utils/compiler/BUILD.gn b/utils/compiler/BUILD.gn
index 5264505..2095edb 100644
--- a/utils/compiler/BUILD.gn
+++ b/utils/compiler/BUILD.gn
@@ -20,35 +20,54 @@
output = "$target_gen_dir/dartdoc_files.stamp"
}
-invoke_dart("dart2js") {
+invoke_dart("dart2js_create_snapshot_entries") {
deps = [
":dart2js_files_stamp",
":runtime_lib_files_stamp",
":dartdoc_files_stamp",
]
+ dot_packages = rebase_path("../../.packages")
+ create_snapshot_entry = rebase_path("create_snapshot_entry.dart")
+ output_dir = rebase_path(root_gen_dir)
+
inputs = [
"../../sdk/lib/_internal/sdk_library_metadata/lib/libraries.dart",
- "create_snapshot.dart",
+ create_snapshot_entry,
"$root_gen_dir/dart2js_files.stamp",
"../../tools/VERSION",
]
- utils_output = "$root_gen_dir/utils_wrapper.dart.snapshot"
- dart2js_output = "$root_gen_dir/dart2js.dart.snapshot"
+ utils_output = "$root_gen_dir/utils_wrapper.dart"
+ dart2js_output = "$root_gen_dir/dart2js.dart"
outputs = [
utils_output,
dart2js_output,
]
- dot_packages = rebase_path("../../.packages")
- create_snapshot = rebase_path("create_snapshot.dart")
- output_dir = rebase_path(root_gen_dir)
-
args = [
"--packages=$dot_packages",
- create_snapshot,
+ create_snapshot_entry,
"--output_dir=$output_dir",
"--dart2js_main=pkg/compiler/lib/src/dart2js.dart",
]
}
+
+application_snapshot("dart2js") {
+ deps = [
+ ":dart2js_create_snapshot_entries"
+ ]
+ main_dart = "$root_gen_dir/dart2js.dart"
+ training_args = [
+ "--library-root=" + rebase_path("../../sdk"),
+ rebase_path("../../tests/language/first_test.dart")
+ ]
+}
+
+application_snapshot("utils_wrapper") {
+ deps = [
+ ":dart2js_create_snapshot_entries"
+ ]
+ main_dart = "$root_gen_dir/utils_wrapper.dart"
+ training_args = [ "--help" ]
+}
diff --git a/utils/compiler/create_snapshot_entry.dart b/utils/compiler/create_snapshot_entry.dart
new file mode 100644
index 0000000..ea9c511
--- /dev/null
+++ b/utils/compiler/create_snapshot_entry.dart
@@ -0,0 +1,95 @@
+// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:io';
+
+Future<String> getVersion(var rootPath) {
+ var suffix = Platform.operatingSystem == 'windows' ? '.exe' : '';
+ var printVersionScript = rootPath.resolve("tools/print_version.py");
+ return Process.run("python$suffix",
+ [printVersionScript.toFilePath()]).then((result) {
+ if (result.exitCode != 0) {
+ throw "Could not generate version";
+ }
+ return result.stdout.trim();
+ });
+}
+
+Future<String> getSnapshotGenerationFile(var args, var rootPath) {
+ var dart2js = rootPath.resolve(args["dart2js_main"]);
+ return getVersion(rootPath).then((version) {
+ var snapshotGenerationText =
+"""
+import '${dart2js.toFilePath(windows: false)}' as dart2jsMain;
+import 'dart:io';
+
+void main(List<String> arguments) {
+ if (arguments.length < 1) throw "No tool given as argument";
+ String tool = arguments[0];
+ if (tool == "dart2js") {
+ dart2jsMain.BUILD_ID = "$version";
+ dart2jsMain.main(arguments.skip(1).toList());
+ }
+}
+
+""";
+ return snapshotGenerationText;
+ });
+}
+
+Future<String> getDart2jsSnapshotGenerationFile(var args, var rootPath) {
+ var dart2js = rootPath.resolve(args["dart2js_main"]);
+ return getVersion(rootPath).then((version) {
+ var snapshotGenerationText =
+"""
+import '${dart2js.toFilePath(windows: false)}' as dart2jsMain;
+
+void main(List<String> arguments) {
+ dart2jsMain.BUILD_ID = "$version";
+ dart2jsMain.main(arguments);
+}
+""";
+ return snapshotGenerationText;
+ });
+}
+
+void writeSnapshotFile(var path, var content) {
+ File file = new File(path);
+ var writer = file.openSync(mode: FileMode.WRITE);
+ writer.writeStringSync(content);
+ writer.close();
+}
+
+/**
+ * Takes the following arguments:
+ * --output_dir=val The full path to the output_dir.
+ * --dart2js_main=val The path to the dart2js main script relative to root.
+ */
+void main(List<String> arguments) {
+ var validArguments = ["--output_dir", "--dart2js_main"];
+ var args = {};
+ for (var argument in arguments) {
+ var argumentSplit = argument.split("=");
+ if (argumentSplit.length != 2) throw "Invalid argument $argument, no =";
+ if (!validArguments.contains(argumentSplit[0])) {
+ throw "Invalid argument $argument";
+ }
+ args[argumentSplit[0].substring(2)] = argumentSplit[1];
+ }
+ if (!args.containsKey("dart2js_main")) throw "Please specify dart2js_main";
+ if (!args.containsKey("output_dir")) throw "Please specify output_dir";
+
+ var scriptFile = Uri.base.resolveUri(Platform.script);
+ var path = scriptFile.resolve(".");
+ var rootPath = path.resolve("../..");
+ getSnapshotGenerationFile(args, rootPath).then((result) {
+ var wrapper = "${args['output_dir']}/utils_wrapper.dart";
+ writeSnapshotFile(wrapper, result);
+ });
+
+ getDart2jsSnapshotGenerationFile(args, rootPath).then((result) {
+ var wrapper = "${args['output_dir']}/dart2js.dart";
+ writeSnapshotFile(wrapper, result);
+ });
+}
diff --git a/utils/dartanalyzer/BUILD.gn b/utils/dartanalyzer/BUILD.gn
index 8f19b1a..9128168 100644
--- a/utils/dartanalyzer/BUILD.gn
+++ b/utils/dartanalyzer/BUILD.gn
@@ -18,6 +18,10 @@
application_snapshot("generate_dartanalyzer_snapshot") {
main_dart = "../../pkg/analyzer_cli/bin/analyzer.dart"
+ training_args = [
+ "--dart-sdk=" + rebase_path("../../sdk"),
+ rebase_path("../../tests/language/first_test.dart")
+ ]
name = "dartanalyzer"
cli_files = exec_script("../../tools/list_dart_files.py",
[rebase_path("../../pkg/analyzer_cli")],
diff --git a/utils/dartdevc/BUILD.gn b/utils/dartdevc/BUILD.gn
index 75507e7..11c94a0 100644
--- a/utils/dartdevc/BUILD.gn
+++ b/utils/dartdevc/BUILD.gn
@@ -6,6 +6,7 @@
application_snapshot("dartdevc") {
main_dart = "../../pkg/dev_compiler/bin/dartdevc.dart"
+ training_args = [ "--help" ]
inputs = exec_script("../../tools/list_dart_files.py",
[rebase_path("../../pkg/dev_compiler/bin")],
"list lines")
diff --git a/utils/dartdoc/BUILD.gn b/utils/dartdoc/BUILD.gn
index d850f02..5c1d0e3 100644
--- a/utils/dartdoc/BUILD.gn
+++ b/utils/dartdoc/BUILD.gn
@@ -6,6 +6,7 @@
application_snapshot("dartdoc") {
main_dart = "../../third_party/pkg/dartdoc/bin/dartdoc.dart"
+ training_args = [ "--help" ]
inputs = exec_script("../../tools/list_dart_files.py",
[rebase_path("../../third_party/pkg/dartdoc")],
"list lines")
diff --git a/utils/dartfmt/BUILD.gn b/utils/dartfmt/BUILD.gn
index f8c820b..f3bbfdc 100644
--- a/utils/dartfmt/BUILD.gn
+++ b/utils/dartfmt/BUILD.gn
@@ -6,6 +6,7 @@
application_snapshot("dartfmt") {
main_dart = "../../third_party/pkg_tested/dart_style/bin/format.dart"
+ training_args = [ "--help" ]
inputs = exec_script("../../tools/list_dart_files.py",
[rebase_path("../../third_party/pkg_tested/dart_style")],
"list lines")
diff --git a/utils/invoke_dart.gni b/utils/invoke_dart.gni
index 66705f7..e300cdb 100644
--- a/utils/invoke_dart.gni
+++ b/utils/invoke_dart.gni
@@ -50,7 +50,9 @@
template("application_snapshot") {
assert(defined(invoker.main_dart), "Must specify 'main_dart'")
+ assert(defined(invoker.training_args), "Must specify 'training_args'")
main_dart = invoker.main_dart
+ training_args = invoker.training_args
name = target_name
if (defined(invoker.name)) {
name = invoker.name
@@ -85,7 +87,8 @@
args = [
"--packages=$dot_packages",
"--snapshot=$abs_output",
- main_file
- ]
+ "--snapshot-kind=app-jit",
+ main_file,
+ ] + training_args
}
}
diff --git a/utils/pub/BUILD.gn b/utils/pub/BUILD.gn
index 4d604e0..7ef2aa4 100644
--- a/utils/pub/BUILD.gn
+++ b/utils/pub/BUILD.gn
@@ -6,6 +6,7 @@
application_snapshot("pub") {
main_dart = "../../third_party/pkg/pub/bin/pub.dart"
+ training_args = [ "--help" ]
deps = [
"../compiler:dart2js_files_stamp"
]
