implement null aware ops, fixes #249

lib/runtime/_operations.js

 // 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.
 
 /* This library defines runtime operations on objects used by the code
  * generator.
  */
 dart_library.library('dart_runtime/_operations', null, /* Imports */[
 ], /* Lazy Imports */[
   'dart/async',
@@ skipping 44 matching lines @@
     }
         return result;
   }
   exports.dload = dload;
 
   function dput(obj, field, value) {
     field = _canonicalFieldName(obj, field, [value], field);
     // TODO(vsm): Implement NSM and type checks.
     // See: https://github.com/dart-lang/dev_compiler/issues/170
     obj[field] = value;
+    return value;
   }
   exports.dput = dput;
 
 
   /// Check that a function of a given type can be applied to
   /// actuals.
   function checkApply(type, actuals) {
     if (actuals.length < type.args.length) return false;
     let index = 0;
     for(let i = 0; i < type.args.length; ++i) {
@@ skipping 86 matching lines @@
     return callMethod(obj, method, slice.call(arguments, 2), method);
   }
   exports.dsend = dsend;
 
   function dindex(obj, index) {
     return callMethod(obj, 'get', [index], '[]');
   }
   exports.dindex = dindex;
 
   function dsetindex(obj, index, value) {
-    return callMethod(obj, 'set', [index, value], '[]=');
+    callMethod(obj, 'set', [index, value], '[]=');
+    return value;
   }
   exports.dsetindex = dsetindex;
 
   function _ignoreTypeFailure(actual, type) {
     // TODO(vsm): Remove this hack ...
     // This is primarily due to the lack of generic methods,
     // but we need to triage all the errors.
     let isSubtype = types.isSubtype;
     if (isSubtype(type, core.Iterable) && isSubtype(actual, core.Iterable) ||
         isSubtype(type, async.Future) && isSubtype(actual, async.Future) ||
@@ skipping 129 matching lines @@
     console.log(error.stack ? error.stack : 'No stack trace for: ' + error);
   }
   exports.stackPrint = stackPrint;
 
   function stackTrace(exception) {
     var error = getError(exception);
     return _js_helper.getTraceFromException(error);
   }
   exports.stackTrace = stackTrace;
 
+  /**
+   * Implements a sequence of .? operations.
+   *
+   * Will call each successive callback, unless one returns null, which stops
+   * the sequence.
+   */
+  function nullSafe(obj /*, ...callbacks*/) {
+    let callbacks = slice.call(arguments, 1);
+    if (obj == null) return obj;
+    for (const callback of callbacks) {
+      obj = callback(obj);
+      if (obj == null) break;
+    }
+    return obj;
+  }
+  exports.nullSafe = nullSafe;
+
   let _value = Symbol('_value');
   /**
    * Looks up a sequence of [keys] in [map], recursively, and
    * returns the result. If the value is not found, [valueFn] will be called to
    * add it. For example:
    *
    *     let map = new Map();
    *     putIfAbsent(map, [1, 2, 'hi ', 'there '], () => 'world');
    *
    * ... will create a Map with a structure like:
@@ skipping 98 matching lines @@
     next() {
       let i = this.dartIterator;
       let done = !i.moveNext();
       return { done: done, value: done ? void 0 : i.current };
     }
   }
   exports.JsIterator = JsIterator;
 
 
 });