Make some VM libraries patch cleanly using the analyzer.

runtime/lib/mirrors_impl.dart

 // Copyright (c) 2012, 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.
 
 // VM-specific implementation of the dart:mirrors library.
 
-var dirty = false;
-final emptyList = new UnmodifiableListView([]);
-final emptyMap = new UnmodifiableMapView({});
+var _dirty = false;
+final _emptyList = new UnmodifiableListView([]);
 
 class _InternalMirrorError {
   final String _msg;
   const _InternalMirrorError(String this._msg);
   String toString() => _msg;
 }
 
 String _n(Symbol symbol) => internal.Symbol.getName(symbol);
 
 Symbol _s(String name) {
@@ skipping 193 matching lines @@
     return assoc.value;
   }
 }
 
 class _LocalMirrorSystem extends MirrorSystem {
   final TypeMirror dynamicType = new _SpecialTypeMirror('dynamic');
   final TypeMirror voidType = new _SpecialTypeMirror('void');
 
   var _libraries;
   Map<Uri, LibraryMirror> get libraries {
-    if ((_libraries == null) || dirty) {
+    if ((_libraries == null) || _dirty) {
       _libraries = new Map<Uri, LibraryMirror>.fromIterable(
           _computeLibraries(), key: (e) => e.uri);
-      dirty = false;
+      _dirty = false;
     }
     return _libraries;
   }
   static _computeLibraries() native "MirrorSystem_libraries";
 
   var _isolate;
   IsolateMirror get isolate {
     if (_isolate == null) {
       _isolate = _computeIsolate();
     }
@@ skipping 59 matching lines @@
   bool get isAbstract => false;
 
   bool get isSetter => !isGetter;
   bool get isPrivate => _n(simpleName).startsWith('_');
 
   Symbol get qualifiedName => _computeQualifiedName(owner, simpleName);
   Symbol get constructorName => const Symbol('');
 
   TypeMirror get returnType => _target.type;
   List<ParameterMirror> get parameters {
-    if (isGetter) return emptyList;
+    if (isGetter) return _emptyList;
     return new UnmodifiableListView(
         [new _SyntheticSetterParameter(this, this._target)]);
   }
 
   SourceLocation get location => null;
-  List<InstanceMirror> get metadata => emptyList;
+  List<InstanceMirror> get metadata => _emptyList;
   String get source => null;
 }
 
 class _SyntheticSetterParameter implements ParameterMirror {
   final DeclarationMirror owner;
   final VariableMirror _target;
 
   _SyntheticSetterParameter(this.owner, this._target);
 
   Symbol get simpleName => _target.simpleName;
   Symbol get qualifiedName => _computeQualifiedName(owner, simpleName);
   TypeMirror get type => _target.type;
 
   bool get isOptional => false;
   bool get isNamed => false;
   bool get isStatic => false;
   bool get isTopLevel => false;
   bool get isConst => false;
   bool get isFinal => true;
   bool get isPrivate => false;
   bool get hasDefaultValue => false;
   InstanceMirror get defaultValue => null;
   SourceLocation get location => null;
-  List<InstanceMirror> get metadata => emptyList;
+  List<InstanceMirror> get metadata => _emptyList;
 }
 
 abstract class _LocalObjectMirror extends _LocalMirror implements ObjectMirror {
   final _reflectee; // May be a MirrorReference or an ordinary object.
 
   _LocalObjectMirror(this._reflectee);
 
   InstanceMirror invoke(Symbol memberName,
                         List positionalArguments,
                         [Map<Symbol, dynamic> namedArguments]) {
@@ skipping 433 matching lines @@
 
   bool get _isAnonymousMixinApplication {
     if (_isMixinAlias) return false;  // Named mixin application.
     if (mixin == this) return false;  // Not a mixin application.
     return true;
   }
 
   List<TypeVariableMirror> _typeVariables = null;
   List<TypeVariableMirror> get typeVariables {
     if (_typeVariables == null) {
-      if (_isAnonymousMixinApplication) return _typeVariables = emptyList;
+      if (_isAnonymousMixinApplication) return _typeVariables = _emptyList;
       _typeVariables = new List<TypeVariableMirror>();
 
       List params = _ClassMirror_type_variables(_reflectee);
       ClassMirror owner = originalDeclaration;
       var mirror;
       for (var i = 0; i < params.length; i += 2) {
         mirror = new _LocalTypeVariableMirror(
             params[i + 1], params[i], owner);
         _typeVariables.add(mirror);
       }
       _typeVariables = new UnmodifiableListView(_typeVariables);
     }
     return _typeVariables;
   }
 
   List<TypeMirror> _typeArguments = null;
   List<TypeMirror> get typeArguments {
     if(_typeArguments == null) {
       if(_isGenericDeclaration || _isAnonymousMixinApplication) {
-        _typeArguments = emptyList;
+        _typeArguments = _emptyList;
       } else {
         _typeArguments =
             new UnmodifiableListView(_computeTypeArguments(_reflectedType));
       }
     }
     return _typeArguments;
   }
 
   bool get isOriginalDeclaration => !_isGeneric || _isGenericDeclaration;
 
@@ skipping 158 matching lines @@
   List<ParameterMirror> get parameters {
     if (_parameters == null) {
       _parameters = _FunctionTypeMirror_parameters(_functionReflectee);
       _parameters = new UnmodifiableListView(_parameters);
     }
     return _parameters;
   }
 
   bool get isOriginalDeclaration => true;
   get originalDeclaration => this;
-  get typeVariables => emptyList;
-  get typeArguments => emptyList;
-  get metadata => emptyList;
+  get typeVariables => _emptyList;
+  get typeArguments => _emptyList;
+  get metadata => _emptyList;
   get location => null;
 
   String toString() => "FunctionTypeMirror on '${_n(simpleName)}'";
 
   MethodMirror _FunctionTypeMirror_call_method(functionReflectee)
       native "FunctionTypeMirror_call_method";
 
   static Type _FunctionTypeMirror_return_type(functionReflectee, instantiator)
       native "FunctionTypeMirror_return_type";
 
@@ skipping 63 matching lines @@
     }
     return _upperBound;
   }
 
   bool get hasReflectedType => false;
   Type get reflectedType {
     throw new UnsupportedError('Type variables have no reflected type');
   }
   Type get _reflectedType => _reflectee;
 
-  List<TypeVariableMirror> get typeVariables => emptyList;
-  List<TypeMirror> get typeArguments => emptyList;
+  List<TypeVariableMirror> get typeVariables => _emptyList;
+  List<TypeMirror> get typeArguments => _emptyList;
 
   bool get isOriginalDeclaration => true;
   TypeMirror get originalDeclaration => this;
 
   String toString() => "TypeVariableMirror on '${_n(simpleName)}'";
 
   operator ==(other) {
     return other is TypeVariableMirror
         && simpleName == other.simpleName
         && owner == other.owner;
@@ skipping 87 matching lines @@
         _typeVariables.add(mirror);
       }
     }
     return _typeVariables;
   }
 
   List<TypeMirror> _typeArguments = null;
   List<TypeMirror> get typeArguments {
     if(_typeArguments == null) {
       if(_isGenericDeclaration) {
-        _typeArguments = emptyList;
+        _typeArguments = _emptyList;
       } else {
         _typeArguments = new UnmodifiableListView(
             _LocalClassMirror._computeTypeArguments(_reflectedType));
       }
     }
     return _typeArguments;
   }
 
   String toString() => "TypedefMirror on '${_n(simpleName)}'";
 
@@ skipping 356 matching lines @@
     return _defaultValue;
   }
 
   bool get hasDefaultValue => _defaultValueReflectee != null;
 
   SourceLocation get location {
     throw new UnsupportedError("ParameterMirror.location unimplemented");
   }
 
   List<InstanceMirror> get metadata {
-    if (_unmirroredMetadata == null) return emptyList;
+    if (_unmirroredMetadata == null) return _emptyList;
     return new UnmodifiableListView(_unmirroredMetadata.map(reflect));
   }
 
   Type get _instantiator {
     return owner._instantiator;
   }
 
   TypeMirror _type = null;
   TypeMirror get type {
     if (_type == null) {
@@ skipping 14 matching lines @@
   final Symbol simpleName;
 
   _SpecialTypeMirror(String name) : simpleName = _s(name);
 
   bool get isPrivate => false;
   bool get isTopLevel => true;
 
   DeclarationMirror get owner => null;
 
   SourceLocation get location => null;
-  List<InstanceMirror> get metadata => emptyList;
+  List<InstanceMirror> get metadata => _emptyList;
 
   bool get hasReflectedType => simpleName == #dynamic;
   Type get reflectedType {
     if (simpleName == #dynamic) return dynamic;
     throw new UnsupportedError("void has no reflected type");
   }
 
-  List<TypeVariableMirror> get typeVariables => emptyList;
-  List<TypeMirror> get typeArguments => emptyList;
+  List<TypeVariableMirror> get typeVariables => _emptyList;
+  List<TypeMirror> get typeArguments => _emptyList;
 
   bool get isOriginalDeclaration => true;
   TypeMirror get originalDeclaration => this;
 
   Symbol get qualifiedName => simpleName;
 
   bool operator ==(other) {
     if (other is! _SpecialTypeMirror) {
       return false;
     }
@@ skipping 51 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instantiationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }