Remove uses of DartObjectImpl

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 231 matching lines @@
     var code = _visit(node);
     if (code != null) _moduleItems.add(code);
   }
 
   @override
   void visitLibraryDirective(LibraryDirective node) {
     assert(_jsModuleValue == null);
 
     var jsName = findAnnotation(node.element, _isJsNameAnnotation);
     _jsModuleValue =
-        getConstantField(jsName, 'name', types.stringType) as String;
+        getConstantField(jsName, 'name', types.stringType)?.toStringValue();
   }
 
   @override
   void visitImportDirective(ImportDirective node) {
     // Nothing to do yet, but we'll want to convert this to an ES6 import once
     // we have support for modules.
   }
 
   @override void visitPartDirective(PartDirective node) {}
   @override void visitPartOfDirective(PartOfDirective node) {}
@@ skipping 131 matching lines @@
         body.add(new JS.Method(_constructorName(ctor), fun));
       }
     }
 
     var classDecl = new JS.ClassDeclaration(new JS.ClassExpression(
         new JS.Identifier(element.name), _classHeritage(element), body));
 
     return _finishClassDef(element.type, classDecl);
   }
 
-  JS.Statement _emitJsType(String dartClassName, DartObjectImpl jsName) {
-    var jsTypeName = getConstantField(jsName, 'name', types.stringType);
+  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 JsName 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 null;
@@ skipping 19 matching lines @@
         methods.add(member);
       }
     }
 
     var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
         _classHeritage(classElem), _emitClassMethods(node, ctors, fields));
 
     String jsPeerName;
     var jsPeer = findAnnotation(classElem, _isJsPeerInterface);
     if (jsPeer != null) {
-      jsPeerName = getConstantField(jsPeer, 'name', types.stringType) as String;
+      jsPeerName =
+          getConstantField(jsPeer, 'name', types.stringType)?.toStringValue();
     }
 
     var body = _finishClassMembers(classElem, classExpr, ctors, fields, methods,
         node.metadata, jsPeerName);
 
     var result = _finishClassDef(type, body);
 
     if (jsPeerName != null) {
       // This class isn't allowed to be lazy, because we need to set up
       // the native JS type eagerly at this point.
@@ skipping 2837 matching lines @@
 /// declaration) as it doesn't have any meaningful rules enforced.
 String jsLibraryName(LibraryElement library) => canonicalLibraryName(library);
 
 /// Shorthand for identifier-like property names.
 /// For now, we emit them as strings and the printer restores them to
 /// identifiers if it can.
 // TODO(jmesserly): avoid the round tripping through quoted form.
 JS.LiteralString _propertyName(String name) => js.string(name, "'");
 
 // TODO(jmesserly): validate the library. See issue #135.
-bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
+bool _isJsNameAnnotation(DartObject value) => value.type.name == 'JsName';
 
-bool _isJsPeerInterface(DartObjectImpl value) =>
+bool _isJsPeerInterface(DartObject value) =>
     value.type.name == 'JsPeerInterface';
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;
 
 /// 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);
 }