Use analyzer's sealed type list

lib/src/checker/resolver.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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 542 matching lines @@
     var element = node.element as LocalVariableElementImpl;
     var exprType = expr.staticType;
     if (exprType is InterfaceType) {
       var iteratedType = _findIteratedType(exprType);
       if (iteratedType != null) {
         element.type = iteratedType;
       }
     }
   }
 
-  List<DartType> _sealedTypes = null;
-
   bool _isSealed(DartType t) {
-    if (_sealedTypes == null) {
-      // TODO(vsm): Use the analyzer's list - see dartbug.com/23125.
-      _sealedTypes = <DartType>[
-        _typeProvider.nullType,
-        _typeProvider.numType,
-        _typeProvider.intType,
-        _typeProvider.doubleType,
-        _typeProvider.boolType,
-        _typeProvider.stringType
-      ];
-    }
-    return _sealedTypes.contains(t);
+    return _typeProvider.nonSubtypableTypes.contains(t);
   }
 
   @override // to propagate types to identifiers
   visitMethodInvocation(MethodInvocation node) {
     // TODO(jmesserly): we rely on having a staticType propagated to the
     // methodName identifier. This shouldn't be necessary for method calls, so
     // analyzer doesn't do it by default. Conceptually what we're doing here
     // is asking for a tear off. We need this until we can fix #132, and rely
     // on `node.staticElement == null` instead of `rules.isDynamicCall(node)`.
     visitSimpleIdentifier(node.methodName);
@@ skipping 90 matching lines @@
     }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is
   // handled by the analyzer internally.
   // TODO(vsm): in visitbinaryExpression: check computeStaticReturnType result?
   // TODO(vsm): in visitFunctionDeclaration: Should we ever use the expression
   // type in a (...) => expr or just the written type?
 
 }