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

lib/src/codegen/js_codegen.dart

 // 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 dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 275 matching lines @@
       if (hide != null) {
         hiddenNames.addAll(hide.hiddenNames.map((i) => js.string(i.name, "'")));
       }
       args.add(new JS.ArrayInitializer(shownNames));
       args.add(new JS.ArrayInitializer(hiddenNames));
     }
     _moduleItems.add(js.statement('dart.export(#);', [args]));
   }
 
   JS.Identifier _initSymbol(JS.Identifier id) {
-    var s = js.statement('let # = $_SYMBOL(#);', [id, js.string(id.name, "'")]);
+    var s = js.statement('const # = $_SYMBOL(#);', [id, js.string(id.name, "'")]);
     _moduleItems.add(s);
     return id;
   }
 
   // TODO(jmesserly): this is a temporary workaround for `Symbol` in core,
   // until we have better name tracking.
   String get _SYMBOL {
     var name = currentLibrary.name;
     if (name == 'dart.core' || name == 'dart._internal') return 'dart.JsSymbol';
     return 'Symbol';
@@ skipping 52 matching lines @@
     return null;
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     var element = node.element;
     var type = element.type;
     var name = element.name;
 
     var fnType = annotateTypeDef(
-        js.statement('let # = dart.typedef(#, () => #);', [
+        js.statement('const # = dart.typedef(#, () => #);', [
           name,
           js.string(name, "'"),
           _emitTypeName(type, lowerTypedef: true)
         ]),
         node.element);
 
     return _finishClassDef(type, fnType);
   }
 
   @override
@@ skipping 25 matching lines @@
   JS.Statement _emitJsType(String dartClassName, DartObject jsName) {
     var jsTypeName =
         getConstantField(jsName, 'name', types.stringType)?.toStringValue();
 
     if (jsTypeName != null && jsTypeName != dartClassName) {
       // We export the JS type as if it was a Dart type. For example this allows
       // `dom.InputElement` to actually be HTMLInputElement.
       // TODO(jmesserly): if we had the JS name on the Element, we could just
       // generate it correctly when we refer to it.
       if (isPublic(dartClassName)) _addExport(dartClassName);
-      return js.statement('let # = #;', [dartClassName, jsTypeName]);
+      return js.statement('const # = #;', [dartClassName, jsTypeName]);
     }
     return null;
   }
 
   @override
   JS.Statement visitClassDeclaration(ClassDeclaration node) {
     var classElem = node.element;
     var type = classElem.type;
     var jsName = findAnnotation(classElem, isJSAnnotation);
 
@@ skipping 129 matching lines @@
       return js.statement('{ #; let # = #; }', [genericDef, name, genericInst]);
     }
     return body;
   }
 
   JS.Statement _emitGenericClassDef(ParameterizedType type, JS.Statement body) {
     var name = type.name;
     var genericName = '$name\$';
     var typeParams = type.typeParameters.map((p) => p.name);
     if (isPublic(name)) _exports.add(genericName);
-    return js.statement('let # = dart.generic(function(#) { #; return #; });',
+    return js.statement('const # = dart.generic(function(#) { #; return #; });',
         [genericName, typeParams, body, name]);
   }
 
   final _hasDeferredSupertype = new HashSet<ClassElement>();
 
   bool _deferIfNeeded(DartType type, ClassElement current) {
     if (type is ParameterizedType) {
       var typeArguments = type.typeArguments;
       for (var typeArg in typeArguments) {
         var typeElement = typeArg.element;
@@ skipping 877 matching lines @@
     var func = node.functionDeclaration;
     if (func.isGetter || func.isSetter) {
       return js.comment('Unimplemented function get/set statement: $node');
     }
 
     var fn = _visit(func.functionExpression);
 
     var name = new JS.Identifier(func.name.name);
     JS.Statement declareFn;
     if (JS.This.foundIn(fn)) {
-      declareFn = js.statement('let # = #.bind(this);', [name, fn]);
+      declareFn = js.statement('const # = #.bind(this);', [name, fn]);
     } else {
       declareFn = new JS.FunctionDeclaration(name, fn);
     }
     declareFn = annotate(declareFn, node.functionDeclaration.element);
 
     return new JS.Block([
       declareFn,
       _emitFunctionTagged(name, func.element.type).toStatement()
     ]);
   }
@@ skipping 566 matching lines @@
       eagerInit = false;
     }
 
     var fieldName = field.name.name;
     if (field.isConst && eagerInit && element is TopLevelVariableElement) {
       // constant fields don't change, so we can generate them as `let`
       // but add them to the module's exports. However, make sure we generate
       // anything they depend on first.
 
       if (isPublic(fieldName)) _addExport(fieldName);
+      var declKeyword = field.isConst || field.isFinal ? 'const' : 'let';
       return annotateVariable(
-          js.statement('let # = #;', [new JS.Identifier(fieldName), jsInit]),
+          js.statement('$declKeyword # = #;',
+              [new JS.Identifier(fieldName), jsInit]),
           field.element);
     }
 
     if (eagerInit && !JS.invalidStaticFieldName(fieldName)) {
       return annotateVariable(
           js.statement('# = #;', [_visit(field.name), jsInit]), field.element);
     }
 
     var body = <JS.Statement>[];
     if (_lazyFields.isNotEmpty) {
@@ skipping 1285 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }