Move FutureImpl and CompleterImpl from coreimpl to core, while also making them private.

lib/core/future_impl.dart

 // Copyright 2012 Google Inc. All Rights Reserved.
 // Dart core library.
 
-class FutureImpl<T> implements Future<T> {
+class _FutureImpl<T> implements Future<T> {
 
   bool _isComplete = false;
 
   /**
    * Value that was provided to this Future by the Completer
    */
   T _value;
 
   /**
    * Exception that occured, if there was a problem providing
@@ skipping 19 matching lines @@
   /**
    * Exception handlers waiting for exceptions.
    */
   final List<Function> _exceptionHandlers;
 
   /**
    * Listeners waiting to be called when the future completes.
    */
   final List<Function> _completionListeners;
 
-  FutureImpl()
+  _FutureImpl()
     : _successListeners = [],
       _exceptionHandlers = [],
       _completionListeners = [];
 
-  factory FutureImpl.immediate(T value) {
-    final res = new FutureImpl();
+  factory _FutureImpl.immediate(T value) {
+    final res = new _FutureImpl();
     res._setValue(value);
     return res;
   }
 
   T get value {
     if (!isComplete) {
       throw new FutureNotCompleteException();
     }
-    if (_exception !== null) {
+    if (_exception != null) {
       throw new FutureUnhandledException(_exception, stackTrace);
     }
     return _value;
   }
 
   Object get exception {
     if (!isComplete) {
       throw new FutureNotCompleteException();
     }
     return _exception;
   }
 
   Object get stackTrace {
     if (!isComplete) {
       throw new FutureNotCompleteException();
     }
     return _stackTrace;
   }
 
   bool get isComplete {
     return _isComplete;
   }
 
   bool get hasValue {
-    return isComplete && _exception === null;
+    return isComplete && _exception == null;
   }
 
   void then(void onSuccess(T value)) {
     if (hasValue) {
       onSuccess(value);
     } else if (!isComplete) {
       _successListeners.add(onSuccess);
     } else if (!_exceptionHandled) {
       throw new FutureUnhandledException(_exception, stackTrace);
     }
@@ skipping 17 matching lines @@
       } catch (e) {}
     } else {
       _completionListeners.add(complete);
     }
   }
 
   void _complete() {
     _isComplete = true;
 
     try {
-      if (_exception !== null) {
+      if (_exception != null) {
         for (Function handler in _exceptionHandlers) {
           // Explicitly check for true here so that if the handler returns null,
           // we don't get an exception in checked mode.
           if (handler(_exception) == true) {
             _exceptionHandled = true;
             break;
           }
         }
       }
 
@@ skipping 17 matching lines @@
 
   void _setValue(T value) {
     if (_isComplete) {
       throw new FutureAlreadyCompleteException();
     }
     _value = value;
     _complete();
   }
 
   void _setException(Object exception, Object stackTrace) {
-    if (exception === null) {
+    if (exception == null) {
       // null is not a legal value for the exception of a Future.
       throw new ArgumentError(null);
     }
     if (_isComplete) {
       throw new FutureAlreadyCompleteException();
     }
     _exception = exception;
     _stackTrace = stackTrace;
     _complete();
   }
@@ skipping 72 matching lines @@
    * Forwards the exception completion from [future] to [completer].
    */
   _forwardException(Future future, Completer completer) {
     future.handleException((e) {
       completer.completeException(e, future.stackTrace);
       return true;
     });
   }
 }
 
-class CompleterImpl<T> implements Completer<T> {
+class _CompleterImpl<T> implements Completer<T> {
 
-  final FutureImpl<T> _futureImpl;
+  final _FutureImpl<T> _futureImpl;
 
-  CompleterImpl() : _futureImpl = new FutureImpl() {}
+  _CompleterImpl() : _futureImpl = new _FutureImpl() {}
 
   Future<T> get future {
     return _futureImpl;
   }
 
   void complete(T value) {
     _futureImpl._setValue(value);
   }
 
   void completeException(Object exception, [Object stackTrace]) {
     _futureImpl._setException(exception, stackTrace);
   }
 }
+