Compile third_party/jstemplate with Closure Compiler

third_party/jstemplate/jsevalcontext.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 32 matching lines @@
  * Un-inlined literals, to avoid object creation in IE6. TODO(mesch):
  * So far, these are only used here, but we could use them thoughout
  * the code and thus move them to constants.js.
  */
 var CHAR_colon = ':';
 var REGEXP_semicolon = /\s*;\s*/;
 
 
 /**
  * See constructor_()
- * @param {Object|null} opt_data
- * @param {Object} opt_parent
+ * @param {Object|null=} opt_data
+ * @param {Object=} opt_parent
  * @constructor
  */
 function JsEvalContext(opt_data, opt_parent) {
   this.constructor_.apply(this, arguments);
 }
 
 /**
  * Context for processing a jstemplate. The context contains a context
  * object, whose properties can be referred to in jstemplate
  * expressions, and it holds the locally defined variables.
  *
  * @param {Object|null} opt_data The context object. Null if no context.
  *
  * @param {Object} opt_parent The parent context, from which local
  * variables are inherited. Normally the context object of the parent
  * context is the object whose property the parent object is. Null for the
  * context of the root object.
+ * @private
  */
 JsEvalContext.prototype.constructor_ = function(opt_data, opt_parent) {
   var me = this;
 
-  /**
-   * The context for variable definitions in which the jstemplate
-   * expressions are evaluated. Other than for the local context,
-   * which replaces the parent context, variable definitions of the
-   * parent are inherited. The special variable $this points to data_.
-   *
-   * If this instance is recycled from the cache, then the property is
-   * already initialized.
-   *
-   * @type {Object}
-   */
   if (!me.vars_) {
+    /**
+     * The context for variable definitions in which the jstemplate
+     * expressions are evaluated. Other than for the local context,
+     * which replaces the parent context, variable definitions of the
+     * parent are inherited. The special variable $this points to data_.
+     *
+     * If this instance is recycled from the cache, then the property is
+     * already initialized.
+     *
+     * @type {Object}
+     */
     me.vars_ = {};
   }
   if (opt_parent) {
     // If there is a parent node, inherit local variables from the
     // parent.
     copyProperties(me.vars_, opt_parent.vars_);
   } else {
     // If a root node, inherit global symbols. Since every parent
     // chain has a root with no parent, global variables will be
     // present in the case above too. This means that globals can be
     // overridden by locals, as it should be.
     copyProperties(me.vars_, JsEvalContext.globals_);
   }
 
   /**
    * The current context object is assigned to the special variable
    * $this so it is possible to use it in expressions.
-   * @type Object
+   * @type {Object}
    */
   me.vars_[VAR_this] = opt_data;
 
   /**
    * The entire context structure is exposed as a variable so it can be
    * passed to javascript invocations through jseval.
    */
   me.vars_[VAR_context] = me;
 
   /**
    * The local context of the input data in which the jstemplate
    * expressions are evaluated. Notice that this is usually an Object,
    * but it can also be a scalar value (and then still the expression
    * $this can be used to refer to it). Notice this can even be value,
    * undefined or null. Hence, we have to protect jsexec() from using
    * undefined or null, yet we want $this to reflect the true value of
    * the current context. Thus we assign the original value to $this,
    * above, but for the expression context we replace null and
    * undefined by the empty string.
    *
-   * @type {Object|null}
+   * @type {*}
    */
   me.data_ = getDefaultObject(opt_data, STRING_empty);
 
   if (!opt_parent) {
     // If this is a top-level context, create a variable reference to the data
     // to allow for  accessing top-level properties of the original context
     // data from child contexts.
     me.vars_[VAR_top] = me.data_;
   }
 };
@@ skipping 120 matching lines @@
   return ret;
 };
 
 
 /**
  * Binds a local variable to the given value. If set from jstemplate
  * jsvalue expressions, variable names must start with $, but in the
  * API they only have to be valid javascript identifier.
  *
  * @param {string} name
- *
- * @param {Object?} value
+ * @param {*} value
  */
 JsEvalContext.prototype.setVariable = function(name, value) {
   this.vars_[name] = value;
 };
 
 
 /**
  * Returns the value bound to the local variable of the given name, or
  * undefined if it wasn't set. There is no way to distinguish a
  * variable that wasn't set from a variable that was set to
  * undefined. Used mostly for testing.
  *
  * @param {string} name
  *
- * @return {Object?} value
+ * @return {*} value
  */
 JsEvalContext.prototype.getVariable = function(name) {
   return this.vars_[name];
 };
 
 
 /**
  * Evaluates a string expression within the scope of this context
  * and returns the result.
  *
@@ skipping 106 matching lines @@
   var ret = [];
   var values = expr.split(REGEXP_semicolon);
   for (var i = 0, I = jsLength(values); i < I; ++i) {
     if (values[i]) {
       var value = jsEvalToFunction(values[i]);
       ret.push(value);
     }
   }
   return ret;
 }