Use const for const/final top-levels, types, symbols.

lib/runtime/dart/_js_helper.js

 dart_library.library('dart/_js_helper', null, /* Imports */[
   "dart/_runtime",
   'dart/core',
   'dart/collection',
   'dart/_interceptors',
   'dart/_foreign_helper'
 ], /* Lazy imports */[
 ], function(exports, dart, core, collection, _interceptors, _foreign_helper) {
   'use strict';
   let dartx = dart.dartx;
@@ skipping 32 matching lines @@
     SupportJsExtensionMethods() {
     }
   }
   dart.setSignature(SupportJsExtensionMethods, {
     constructors: () => ({SupportJsExtensionMethods: [SupportJsExtensionMethods, []]})
   });
   function defineProperty(obj, property, value) {
     Object.defineProperty(obj, property, {value: value, enumerable: false, writable: true, configurable: true});
   }
   dart.fn(defineProperty, dart.void, [dart.dynamic, core.String, dart.dynamic]);
-  let _nativeRegExp = Symbol('_nativeRegExp');
+  const _nativeRegExp = Symbol('_nativeRegExp');
   function regExpGetNative(regexp) {
     return regexp[_nativeRegExp];
   }
   dart.fn(regExpGetNative, () => dart.definiteFunctionType(dart.dynamic, [JSSyntaxRegExp]));
-  let _nativeGlobalVersion = Symbol('_nativeGlobalVersion');
+  const _nativeGlobalVersion = Symbol('_nativeGlobalVersion');
   function regExpGetGlobalNative(regexp) {
     let nativeRegexp = regexp[_nativeGlobalVersion];
     nativeRegexp.lastIndex = 0;
     return nativeRegexp;
   }
   dart.fn(regExpGetGlobalNative, () => dart.definiteFunctionType(dart.dynamic, [JSSyntaxRegExp]));
-  let _nativeAnchoredVersion = Symbol('_nativeAnchoredVersion');
+  const _nativeAnchoredVersion = Symbol('_nativeAnchoredVersion');
   function regExpCaptureCount(regexp) {
     let nativeAnchoredRegExp = regexp[_nativeAnchoredVersion];
     let match = nativeAnchoredRegExp.exec('');
     return dart.as(dart.dsend(dart.dload(match, 'length'), '-', 2), core.int);
   }
   dart.fn(regExpCaptureCount, () => dart.definiteFunctionType(core.int, [JSSyntaxRegExp]));
-  let _nativeGlobalRegExp = Symbol('_nativeGlobalRegExp');
-  let _nativeAnchoredRegExp = Symbol('_nativeAnchoredRegExp');
-  let _isMultiLine = Symbol('_isMultiLine');
-  let _isCaseSensitive = Symbol('_isCaseSensitive');
-  let _execGlobal = Symbol('_execGlobal');
-  let _execAnchored = Symbol('_execAnchored');
+  const _nativeGlobalRegExp = Symbol('_nativeGlobalRegExp');
+  const _nativeAnchoredRegExp = Symbol('_nativeAnchoredRegExp');
+  const _isMultiLine = Symbol('_isMultiLine');
+  const _isCaseSensitive = Symbol('_isCaseSensitive');
+  const _execGlobal = Symbol('_execGlobal');
+  const _execAnchored = Symbol('_execAnchored');
   class JSSyntaxRegExp extends core.Object {
     toString() {
       return `RegExp/${this.pattern}/`;
     }
     JSSyntaxRegExp(source, opts) {
       let multiLine = opts && 'multiLine' in opts ? opts.multiLine : false;
       let caseSensitive = opts && 'caseSensitive' in opts ? opts.caseSensitive : true;
       this.pattern = source;
       this[_nativeRegExp] = JSSyntaxRegExp.makeNative(source, multiLine, caseSensitive, false);
       this[_nativeGlobalRegExp] = null;
@@ skipping 101 matching lines @@
       stringMatch: [core.String, [core.String]],
       allMatches: [core.Iterable$(core.Match), [core.String], [core.int]],
       [_execGlobal]: [core.Match, [core.String, core.int]],
       [_execAnchored]: [core.Match, [core.String, core.int]],
       matchAsPrefix: [core.Match, [core.String], [core.int]]
     }),
     statics: () => ({makeNative: [dart.dynamic, [core.String, core.bool, core.bool, core.bool]]}),
     names: ['makeNative']
   });
   dart.defineExtensionMembers(JSSyntaxRegExp, ['allMatches', 'matchAsPrefix']);
-  let _match = Symbol('_match');
+  const _match = Symbol('_match');
   class _MatchImplementation extends core.Object {
     _MatchImplementation(pattern, match) {
       this.pattern = pattern;
       this[_match] = match;
       dart.assert(typeof this[_match].input == 'string');
       dart.assert(typeof this[_match].index == 'number');
     }
     get input() {
       return this[_match].input;
     }
@@ skipping 22 matching lines @@
   }
   _MatchImplementation[dart.implements] = () => [core.Match];
   dart.setSignature(_MatchImplementation, {
     constructors: () => ({_MatchImplementation: [_MatchImplementation, [core.Pattern, core.List$(core.String)]]}),
     methods: () => ({
       group: [core.String, [core.int]],
       get: [core.String, [core.int]],
       groups: [core.List$(core.String), [core.List$(core.int)]]
     })
   });
-  let _re = Symbol('_re');
-  let _string = Symbol('_string');
-  let _start = Symbol('_start');
+  const _re = Symbol('_re');
+  const _string = Symbol('_string');
+  const _start = Symbol('_start');
   class _AllMatchesIterable extends collection.IterableBase$(core.Match) {
     _AllMatchesIterable(re, string, start) {
       this[_re] = re;
       this[_string] = string;
       this[_start] = start;
       super.IterableBase();
     }
     get iterator() {
       return new _AllMatchesIterator(this[_re], this[_string], this[_start]);
     }
   }
   dart.setSignature(_AllMatchesIterable, {
     constructors: () => ({_AllMatchesIterable: [_AllMatchesIterable, [JSSyntaxRegExp, core.String, core.int]]})
   });
   dart.defineExtensionMembers(_AllMatchesIterable, ['iterator']);
-  let _regExp = Symbol('_regExp');
-  let _nextIndex = Symbol('_nextIndex');
-  let _current = Symbol('_current');
+  const _regExp = Symbol('_regExp');
+  const _nextIndex = Symbol('_nextIndex');
+  const _current = Symbol('_current');
   class _AllMatchesIterator extends core.Object {
     _AllMatchesIterator(regExp, string, nextIndex) {
       this[_regExp] = regExp;
       this[_string] = string;
       this[_nextIndex] = nextIndex;
       this[_current] = null;
     }
     get current() {
       return this[_current];
     }
@@ skipping 104 matching lines @@
   dart.fn(stringReplaceJS);
   function stringReplaceFirstRE(receiver, regexp, to, startIndex) {
     let match = dart.dsend(regexp, _execGlobal, receiver, startIndex);
     if (match == null)
       return receiver;
     let start = dart.dload(match, 'start');
     let end = dart.dload(match, 'end');
     return `${dart.dsend(receiver, 'substring', 0, start)}${to}${dart.dsend(receiver, 'substring', end)}`;
   }
   dart.fn(stringReplaceFirstRE);
-  let ESCAPE_REGEXP = '[[\\]{}()*+?.\\\\^$|]';
+  const ESCAPE_REGEXP = '[[\\]{}()*+?.\\\\^$|]';
   function stringReplaceAllUnchecked(receiver, from, to) {
     checkString(to);
     if (typeof from == 'string') {
       if (dart.equals(from, "")) {
         if (dart.equals(receiver, "")) {
           return to;
         } else {
           let result = new core.StringBuffer();
           let length = dart.as(dart.dload(receiver, 'length'), core.int);
           result.write(to);
@@ skipping 131 matching lines @@
     return dart.is(value, _interceptors.JSArray);
   }
   dart.fn(isJsArray, core.bool, [dart.dynamic]);
   class _Patch extends core.Object {
     _Patch() {
     }
   }
   dart.setSignature(_Patch, {
     constructors: () => ({_Patch: [_Patch, []]})
   });
-  let patch = dart.const(new _Patch());
+  const patch = dart.const(new _Patch());
   class InternalMap extends core.Object {}
   class Primitives extends core.Object {
     static initializeStatics(id) {
       Primitives.mirrorFunctionCacheName = dart.notNull(Primitives.mirrorFunctionCacheName) + `_${id}`;
       Primitives.mirrorInvokeCacheName = dart.notNull(Primitives.mirrorInvokeCacheName) + `_${id}`;
     }
     static objectHashCode(object) {
       let hash = dart.as(object.$identityHash, core.int);
       if (hash == null) {
         hash = Math.random() * 0x3fffffff | 0;
@@ skipping 364 matching lines @@
   }
   dart.fn(checkString);
   function throwRuntimeError(message) {
     dart.throw(new RuntimeError(message));
   }
   dart.fn(throwRuntimeError);
   function throwAbstractClassInstantiationError(className) {
     dart.throw(new core.AbstractClassInstantiationError(dart.as(className, core.String)));
   }
   dart.fn(throwAbstractClassInstantiationError);
-  let _message = Symbol('_message');
-  let _method = Symbol('_method');
+  const _message = Symbol('_message');
+  const _method = Symbol('_method');
   class NullError extends core.Error {
     NullError(message, match) {
       this[_message] = message;
       this[_method] = match == null ? null : dart.as(match.method, core.String);
       super.Error();
     }
     toString() {
       if (this[_method] == null)
         return `NullError: ${this[_message]}`;
       return `NullError: Cannot call "${this[_method]}" on null`;
     }
   }
   NullError[dart.implements] = () => [core.NoSuchMethodError];
   dart.setSignature(NullError, {
     constructors: () => ({NullError: [NullError, [core.String, dart.dynamic]]})
   });
-  let _receiver = Symbol('_receiver');
+  const _receiver = Symbol('_receiver');
   class JsNoSuchMethodError extends core.Error {
     JsNoSuchMethodError(message, match) {
       this[_message] = message;
       this[_method] = match == null ? null : dart.as(match.method, core.String);
       this[_receiver] = match == null ? null : dart.as(match.receiver, core.String);
       super.Error();
     }
     toString() {
       if (this[_method] == null)
         return `NoSuchMethodError: ${this[_message]}`;
@@ skipping 16 matching lines @@
       return dart.notNull(this[_message][dartx.isEmpty]) ? 'Error' : `Error: ${this[_message]}`;
     }
   }
   dart.setSignature(UnknownJsTypeError, {
     constructors: () => ({UnknownJsTypeError: [UnknownJsTypeError, [core.String]]})
   });
   function getTraceFromException(exception) {
     return new _StackTrace(exception);
   }
   dart.fn(getTraceFromException, core.StackTrace, [dart.dynamic]);
-  let _exception = Symbol('_exception');
-  let _trace = Symbol('_trace');
+  const _exception = Symbol('_exception');
+  const _trace = Symbol('_trace');
   class _StackTrace extends core.Object {
     _StackTrace(exception) {
       this[_exception] = exception;
       this[_trace] = null;
     }
     toString() {
       if (this[_trace] != null)
         return this[_trace];
       let trace = null;
       if (typeof this[_exception] === "object") {
@@ skipping 130 matching lines @@
   function random64() {
     let int32a = Math.random() * 0x100000000 >>> 0;
     let int32b = Math.random() * 0x100000000 >>> 0;
     return dart.notNull(int32a) + dart.notNull(int32b) * 4294967296;
   }
   dart.fn(random64, core.int, []);
   function jsonEncodeNative(string) {
     return JSON.stringify(string);
   }
   dart.fn(jsonEncodeNative, core.String, [core.String]);
-  let _jsIterator = Symbol('_jsIterator');
-  let SyncIterator$ = dart.generic(function(E) {
+  const _jsIterator = Symbol('_jsIterator');
+  const SyncIterator$ = dart.generic(function(E) {
     class SyncIterator extends core.Object {
       SyncIterator(jsIterator) {
         this[_jsIterator] = jsIterator;
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         let ret = this[_jsIterator].next();
         this[_current] = dart.as(ret.value, E);
         return !ret.done;
       }
     }
     SyncIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(SyncIterator, {
       constructors: () => ({SyncIterator: [SyncIterator$(E), [dart.dynamic]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return SyncIterator;
   });
   let SyncIterator = SyncIterator$();
-  let _generator = Symbol('_generator');
-  let _args = Symbol('_args');
-  let SyncIterable$ = dart.generic(function(E) {
+  const _generator = Symbol('_generator');
+  const _args = Symbol('_args');
+  const SyncIterable$ = dart.generic(function(E) {
     class SyncIterable extends collection.IterableBase$(E) {
       SyncIterable(generator, args) {
         this[_generator] = generator;
         this[_args] = args;
         super.IterableBase();
       }
       [_jsIterator]() {
         return this[_generator](...this[_args]);
       }
       get iterator() {
@@ skipping 64 matching lines @@
   exports.CastErrorImplementation = CastErrorImplementation;
   exports.FallThroughErrorImplementation = FallThroughErrorImplementation;
   exports.RuntimeError = RuntimeError;
   exports.random64 = random64;
   exports.jsonEncodeNative = jsonEncodeNative;
   exports.SyncIterator$ = SyncIterator$;
   exports.SyncIterator = SyncIterator;
   exports.SyncIterable$ = SyncIterable$;
   exports.SyncIterable = SyncIterable;
 });