Compile third_party/jstemplate with Closure Compiler

third_party/jstemplate/util.js

 // Copyright 2006 Google Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 37 matching lines @@
   try {
     // NOTE(mesch): An alternative idiom would be:
     //
     //   eval('(' + expr + ')');
     //
     // Note that using the square brackets as below, "" evals to undefined.
     // The alternative of using parentheses does not work when evaluating
     // function literals in IE.
     // e.g. eval("(function() {})") returns undefined, and not a function
     // object, in IE.
-    return eval('[' + expr + '][0]');
+    var object = eval('[' + expr + '][0]');

[Dan Beam, 2014/09/26 19:10:30]

nit: var result

[Vitaly Pavlenko, 2014/09/26 19:46:12]

Done.

+    if (typeof object != 'object') {
+      throw new Error('expression of type Object expected, ' +
+                      typeof object + ' found');
+    }
+    return /** @type {Object} */(object);
   } catch (e) {
     log('EVAL FAILED ' + expr + ': ' + e);
     return null;
   }
 }
 
 function jsLength(obj) {
   return obj.length;
 }
 
-function assert(obj) {}
-
 /**
  * Copies all properties from second object to the first.  Modifies to.
  *
  * @param {Object} to  The target object.
  * @param {Object} from  The source object.
  */
 function copyProperties(to, from) {
   for (var p in from) {
     to[p] = from[p];
   }
 }
 
 
 /**
- * @param {Object|null|undefined} value The possible value to use.
- * @param {Object} defaultValue The default if the value is not set.
- * @return {Object} The value, if it is
- * defined and not null; otherwise the default
+ * @param {*} value The possible value to use.
+ * @param {*} defaultValue The default if the value is not set.
+ * @return {*} The value, if it is defined and not null; otherwise the default.
  */
 function getDefaultObject(value, defaultValue) {
   if (typeof value != TYPE_undefined && value != null) {
-    return /** @type Object */(value);
+    return value;
   } else {
     return defaultValue;
   }
 }
 
 /**
  * Detect if an object looks like an Array.
  * Note that instanceof Array is not robust; for example an Array
  * created in another iframe fails instanceof Array.
  * @param {Object|null} value Object to interrogate
  * @return {boolean} Is the object an array?
  */
 function isArray(value) {
   return value != null &&
       typeof value == TYPE_object &&
       typeof value.length == TYPE_number;
 }
 
 
 /**
  * Finds a slice of an array.
  *
- * @param {Array} array  Array to be sliced.
+ * @param {Array|Arguments} array  Array to be sliced.
  * @param {number} start  The start of the slice.
- * @param {number} opt_end  The end of the slice (optional).
+ * @param {number=} opt_end  The end of the slice (optional).
  * @return {Array} array  The slice of the array from start to end.
  */
 function arraySlice(array, start, opt_end) {
   // Use
   //   return Function.prototype.call.apply(Array.prototype.slice, arguments);
   // instead of the simpler
   //   return Array.prototype.slice.call(array, start, opt_end);
   // here because of a bug in the FF and IE implementations of
   // Array.prototype.slice which causes this function to return an empty list
   // if opt_end is not provided.
-  return Function.prototype.call.apply(Array.prototype.slice, arguments);
+  return /** @type {Array} */(
+      Function.prototype.call.apply(Array.prototype.slice, arguments));
 }
 
 
 /**
  * Jscompiler wrapper for parseInt() with base 10.
  *
  * @param {string} s string repersentation of a number.
  *
  * @return {number} The integer contained in s, converted on base 10.
  */
@@ skipping 15 matching lines @@
 
 
 /**
  * Prebinds "this" within the given method to an object, but ignores all
  * arguments passed to the resulting function.
  * I.e. var_args are all the arguments that method is invoked with when
  * invoking the bound function.
  *
  * @param {Object|null} object  The object that the method call targets.
  * @param {Function} method  The target method.
+ * @param {...*} var_args
  * @return {Function}  Method with the target object bound to it and curried by
  *                     the provided arguments.
  */
 function bindFully(object, method, var_args) {
   var args = arraySlice(arguments, 2);
   return function() {
     return method.apply(object, args);
   }
 }
 
@@ skipping 239 matching lines @@
  * @param {Node} node  The node to remove.
  * @return {Node}  The removed node.
  */
 function domRemoveNode(node) {
   return domRemoveChild(node.parentNode, node);
 }
 
 /**
  * Remove a child from the specified (parent) node.
  *
- * @param {Element} node  Parent element.
+ * @param {Node} node  Parent element.
  * @param {Node} child  Child node to remove.
  * @return {Node}  Removed node.
  */
 function domRemoveChild(node, child) {
   return node.removeChild(child);
 }
 
 
 /**
  * Trim whitespace from begin and end of string.
@@ skipping 23 matching lines @@
  * Trim whitespace from end of string.
  *
  * @see testStringTrimRight();
  *
  * @param {string} str  Input string.
  * @return {string}  Trimmed string.
   */
 function stringTrimRight(str) {
   return str.replace(/\s+$/, "");
 }