Shorten Closure template notation from Array.<*> to Array<*> in cvox.

chrome/browser/resources/chromeos/chromevox/common/math_semantic_tree.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview A semantic tree for MathML expressions.
  *
  * This file contains functionality to compute a semantic interpretation from a
  * given MathML expression. This is a very heuristic approach that assumes a
  * fairly simple default semantic which is suitable for K-12 and simple UG
@@ skipping 32 matching lines @@
 
 
 /**
  * @param {number} id Node id.
  * @constructor
  */
 cvox.SemanticTree.Node = function(id) {
   /** @type {number} */
   this.id = id;
 
-  /** @type {Array.<Element>} */
+  /** @type {Array<Element>} */
   this.mathml = [];
 
   /** @type {cvox.SemanticTree.Node} */
   this.parent = null;
 
   /** @type {cvox.SemanticAttr.Type} */
   this.type = cvox.SemanticAttr.Type.UNKNOWN;
 
   /** @type {cvox.SemanticAttr.Role} */
   this.role = cvox.SemanticAttr.Role.UNKNOWN;
 
   /** @type {cvox.SemanticAttr.Font} */
   this.font = cvox.SemanticAttr.Font.UNKNOWN;
 
-  /** @type {!Array.<cvox.SemanticTree.Node>} */
+  /** @type {!Array<cvox.SemanticTree.Node>} */
   this.childNodes = [];
 
   /** @type {string} */
   this.textContent = '';
 
   /** Branch nodes can store additional nodes that can be useful.
    * E.g. a node of type FENCED can have the opening and closing fences here.
-   * @type {!Array.<cvox.SemanticTree.Node>}
+   * @type {!Array<cvox.SemanticTree.Node>}
    */
   this.contentNodes = [];
 };
 
 
 /**
  * Retrieve all subnodes (including the node itself) that satisfy a given
  * predicate.
  * @param {function(cvox.SemanticTree.Node): boolean} pred The predicate.
- * @return {!Array.<cvox.SemanticTree.Node>} The nodes in the tree for which the
+ * @return {!Array<cvox.SemanticTree.Node>} The nodes in the tree for which the
  *     predicate holds.
  */
 cvox.SemanticTree.Node.prototype.querySelectorAll = function(pred) {
   var result = [];
   for (var i = 0, child; child = this.childNodes[i]; i++) {
     result = result.concat(child.querySelectorAll(pred));
   }
   if (pred(this)) {
     result.unshift(this);
   }
@@ skipping 20 matching lines @@
  /**
   * An XML tree representation of the current node.
   * @param {Document} xml The XML document.
   * @param {boolean=} brief If set attributes are omitted.
   * @return {Node} The XML representation of the node.
   */
  cvox.SemanticTree.Node.prototype.xml = function(xml, brief) {
    /**
     * Translates a list of nodes into XML representation.
     * @param {string} tag Name of the enclosing tag.
-    * @param {!Array.<!cvox.SemanticTree.Node>} nodes A list of nodes.
+    * @param {!Array<!cvox.SemanticTree.Node>} nodes A list of nodes.
     * @return {Node} An XML representation of the node list.
     */
    var xmlNodeList = function(tag, nodes) {
      var xmlNodes = nodes.map(function(x) {return x.xml(xml, brief);});
      var tagNode = xml.createElement(tag);
      for (var i = 0, child; child = xmlNodes[i]; i++) {
        tagNode.appendChild(child);
      }
      return tagNode;
    };
@@ skipping 138 matching lines @@
   this.role = meaning.role;
   this.type = meaning.type;
   this.font = meaning.font;
 };
 
 
 /**
  * Adds MathML nodes to the node's store of MathML nodes if necessary only, as
  * we can not necessarily assume that the MathML of the content nodes and
  * children are all disjoint.
- * @param {Array.<Node>} mmlNodes List of MathML nodes.
+ * @param {Array<Node>} mmlNodes List of MathML nodes.
  * @private
  */
 cvox.SemanticTree.Node.prototype.addMathmlNodes_ = function(mmlNodes) {
   for (var i = 0, mml; mml = mmlNodes[i]; i++) {
     if (this.mathml.indexOf(mml) == -1) {
       this.mathml.push(mml);
     }
   }
 };
 
 
 /**
  * Removes MathML nodes from the node's store of MathML nodes.
- * @param {Array.<Node>} mmlNodes List of MathML nodes.
+ * @param {Array<Node>} mmlNodes List of MathML nodes.
  * @private
  */
 cvox.SemanticTree.Node.prototype.removeMathmlNodes_ = function(mmlNodes) {
   var mmlList = this.mathml;
   for (var i = 0, mml; mml = mmlNodes[i]; i++) {
     var index = mmlList.indexOf(mml);
     if (index != -1) {
       mmlList.splice(index, 1);
     }
   }
@@ skipping 175 matching lines @@
     // TODO (sorge) Do something useful with error and phantom symbols.
     default:
     // Ordinarilly at this point we should not get any other tag.
       return this.makeUnprocessed_(mml);
   }
 };
 
 
 /**
  * Parse a list of MathML nodes into the semantic tree.
- * @param {Array.<Element>} mmls A list of MathML nodes.
- * @return {!Array.<cvox.SemanticTree.Node>} The list of resulting semantic
+ * @param {Array<Element>} mmls A list of MathML nodes.
+ * @return {!Array<cvox.SemanticTree.Node>} The list of resulting semantic
  *     node.
  * @private
  */
 cvox.SemanticTree.prototype.parseMathmlChildren_ = function(mmls) {
   var result = [];
   for (var i = 0, mml; mml = mmls[i]; i++) {
     result.push(this.parseMathml_(mml));
   }
   return result;
 };
@@ skipping 34 matching lines @@
   node.mathml = [mml];
   node.updateContent_(mml.textContent);
   node.font = mml.getAttribute('mathvariant') || node.font;
   return node;
 };
 
 
 /**
  * Create a branching node.
  * @param {!cvox.SemanticAttr.Type} type The type of the node.
- * @param {!Array.<cvox.SemanticTree.Node>} children The child nodes.
- * @param {!Array.<cvox.SemanticTree.Node>} contentNodes The content Nodes.
+ * @param {!Array<cvox.SemanticTree.Node>} children The child nodes.
+ * @param {!Array<cvox.SemanticTree.Node>} contentNodes The content Nodes.
  * @param {string=} content Content string if there is any.
  * @return {!cvox.SemanticTree.Node} The new node.
  * @private
  */
 cvox.SemanticTree.prototype.makeBranchNode_ = function(
     type, children, contentNodes, content) {
   var node = this.createNode_();
   if (content) {
     node.updateContent_(content);
   }
   node.type = type;
   node.childNodes = children;
   node.contentNodes = contentNodes;
   children.concat(contentNodes)
       .forEach(
           function(x) {
             x.parent = node;
             node.addMathmlNodes_(x.mathml);
           });
   return node;
 };
 
 
 /**
  * Create a branching node for an implicit operation, currently assumed to
  * be of multiplicative type.
- * @param {!Array.<!cvox.SemanticTree.Node>} nodes The operands.
+ * @param {!Array<!cvox.SemanticTree.Node>} nodes The operands.
  * @return {!cvox.SemanticTree.Node} The new branch node.
  * @private
  */
 cvox.SemanticTree.prototype.makeImplicitNode_ = function(nodes) {
   if (nodes.length == 1) {
     return nodes[0];
     }
   var operator = this.createNode_();
   // For now we assume this is a multiplication using invisible times.
   operator.updateContent_(cvox.SemanticAttr.invisibleTimes());
   var newNode = this.makeInfixNode_(nodes, operator);
   newNode.role = cvox.SemanticAttr.Role.IMPLICIT;
   return newNode;
 };
 
 
 /**
  * Create a branching node for an infix operation.
- * @param {!Array.<cvox.SemanticTree.Node>} children The operands.
+ * @param {!Array<cvox.SemanticTree.Node>} children The operands.
  * @param {!cvox.SemanticTree.Node} opNode The operator.
  * @return {!cvox.SemanticTree.Node} The new branch node.
  * @private
  */
 cvox.SemanticTree.prototype.makeInfixNode_ = function(children, opNode) {
   return this.makeBranchNode_(
       cvox.SemanticAttr.Type.INFIXOP, children, [opNode], opNode.textContent);
 };
 
 
 /**
  * Creates a node of the specified type by collapsing the given node list into
  * one content (thereby concatenating the content of each node into a single
  * content string) with the inner node as a child.
  * @param {!cvox.SemanticTree.Node} inner The inner node.
- * @param {!Array.<cvox.SemanticTree.Node>} nodeList List of nodes.
+ * @param {!Array<cvox.SemanticTree.Node>} nodeList List of nodes.
  * @param {!cvox.SemanticAttr.Type} type The new type of the node.
  * @return {!cvox.SemanticTree.Node} The new branch node.
  * @private
  */
 cvox.SemanticTree.prototype.makeConcatNode_ = function(inner, nodeList, type) {
   if (nodeList.length == 0) {
     return inner;
   }
   var content = nodeList.map(function(x) {return x.textContent;}).join(' ');
   var newNode = this.makeBranchNode_(type, [inner], nodeList, content);
   if (nodeList.length > 0) {
     newNode.role = cvox.SemanticAttr.Role.MULTIOP;
   }
   return newNode;
 };
 
 
 /**
  * Wraps a node into prefix operators.
  * Example: + - a becomes (+ (- (a)))
  * Input: a  [+, -] ->  Output: content: '+ -', child: a
  * @param {!cvox.SemanticTree.Node} node The inner node.
- * @param {!Array.<cvox.SemanticTree.Node>} prefixes Prefix operators
+ * @param {!Array<cvox.SemanticTree.Node>} prefixes Prefix operators
  * from the outermost to the innermost.
  * @return {!cvox.SemanticTree.Node} The new branch node.
  * @private
  */
 cvox.SemanticTree.prototype.makePrefixNode_ = function(node, prefixes) {
   var negatives = cvox.SemanticTree.partitionNodes_(
       prefixes, cvox.SemanticTree.attrPred_('role', 'SUBTRACTION'));
   var newNode = this.makeConcatNode_(
       node, negatives.comp.pop(), cvox.SemanticAttr.Type.PREFIXOP);
 
   while (negatives.rel.length > 0) {
     newNode = this.makeConcatNode_(
         newNode, [negatives.rel.pop()], cvox.SemanticAttr.Type.PREFIXOP);
     newNode.role = cvox.SemanticAttr.Role.NEGATIVE;
     newNode = this.makeConcatNode_(
         newNode, negatives.comp.pop(), cvox.SemanticAttr.Type.PREFIXOP);
   }
   return newNode;
 };
 
 
 /**
  * Wraps a node into postfix operators.
  * Example: a - + becomes (((a) -) +)
  * Input: a  [-, +] ->  Output: content: '- +', child: a
  * @param {!cvox.SemanticTree.Node} node The inner node.
- * @param {!Array.<cvox.SemanticTree.Node>} postfixes Postfix operators from
+ * @param {!Array<cvox.SemanticTree.Node>} postfixes Postfix operators from
  * innermost to outermost.
  * @return {!cvox.SemanticTree.Node} The new branch node.
  * @private
  */
 cvox.SemanticTree.prototype.makePostfixNode_ = function(node, postfixes) {
   return this.makeConcatNode_(
       node, postfixes, cvox.SemanticAttr.Type.POSTFIXOP);
 };
 
 
 // TODO (sorge) Separate out interspersed text before the relations in row
 // heuristic otherwise we get them as implicit operations!
 // Currently we handle that later in the rules, which is rather messy.
 /**
  * Processes a list of nodes, combining expressions by delimiters, tables,
  * punctuation sequences, function/big operator/integral applications to
  * generate a syntax tree with relation and operator precedence.
  *
  * This is the main heuristic to rewrite a flat row of terms into a meaningful
  * term tree.
- * @param {!Array.<cvox.SemanticTree.Node>} nodes The list of nodes.
+ * @param {!Array<cvox.SemanticTree.Node>} nodes The list of nodes.
  * @return {!cvox.SemanticTree.Node} The root node of the syntax tree.
  * @private
  */
 cvox.SemanticTree.prototype.processRow_ = function(nodes) {
   if (nodes.length == 0) {
     return this.makeEmptyNode_();
   }
   nodes = this.getFencesInRow_(nodes);
   nodes = this.processTablesInRow_(nodes);
   nodes = this.getPunctuationInRow_(nodes);
   nodes = this.getFunctionsInRow_(nodes);
   return this.processRelationsInRow_(nodes);
 };
 
 
 /**
  * Constructs a syntax tree with relation and operator precedence from a list
  * of nodes.
- * @param {!Array.<!cvox.SemanticTree.Node>} nodes The list of nodes.
+ * @param {!Array<!cvox.SemanticTree.Node>} nodes The list of nodes.
  * @return {!cvox.SemanticTree.Node} The root node of the syntax tree.
  * @private
  */
 cvox.SemanticTree.prototype.processRelationsInRow_ = function(nodes) {
   var partition = cvox.SemanticTree.partitionNodes_(
       nodes, cvox.SemanticTree.attrPred_('type', 'RELATION'));
   var firstRel = partition.rel[0];
 
   if (!firstRel) {
     return this.processOperationsInRow_(nodes);
   }
   if (nodes.length == 1) {
     return nodes[0];
   }
   var children = partition.comp.map(
       goog.bind(this.processOperationsInRow_, this));
   if (partition.rel.every(
          function(x) {return x.textContent == firstRel.textContent;})) {
     return this.makeBranchNode_(
         cvox.SemanticAttr.Type.RELSEQ, children, partition.rel,
         firstRel.textContent);
   }
   return this.makeBranchNode_(
       cvox.SemanticAttr.Type.MULTIREL, children, partition.rel);
 };
 
 
 /**
  * Constructs a syntax tree with operator precedence from a list nodes.
- * @param {!Array.<!cvox.SemanticTree.Node>} nodes The list of nodes.
+ * @param {!Array<!cvox.SemanticTree.Node>} nodes The list of nodes.
  * @return {!cvox.SemanticTree.Node} The root node of the syntax tree.
  * @private
  */
 cvox.SemanticTree.prototype.processOperationsInRow_ = function(nodes) {
   if (nodes.length == 0) {
     return this.makeEmptyNode_();
   }
   if (nodes.length == 1) {
     return nodes[0];
   }
 
   var prefix = [];
   while (nodes.length > 0 &&
       nodes[0].type == cvox.SemanticAttr.Type.OPERATOR) {
     prefix.push(nodes.shift());
   }
   // Pathological case: only operators in row.
   if (nodes.length == 0) {
     return this.makePrefixNode_(prefix.pop(), prefix);
   }
   if (nodes.length == 1) {
     return this.makePrefixNode_(nodes[0], prefix);
   }
 
   var split = cvox.SemanticTree.sliceNodes_(
       nodes, cvox.SemanticTree.attrPred_('type', 'OPERATOR'));
   // At this point, we know that split.head is not empty!
   var node = this.makePrefixNode_(
       this.makeImplicitNode_(
-          /** @type {!Array.<!cvox.SemanticTree.Node>} */ (split.head)),
+          /** @type {!Array<!cvox.SemanticTree.Node>} */ (split.head)),
       prefix);
   if (!split.div) {
     return node;
   }
   return this.makeOperationsTree_(split.tail, node, split.div);
 };
 
 
 /**
  * Recursively constructs syntax tree with operator precedence from a list nodes
  * given a initial root node.
- * @param {!Array.<cvox.SemanticTree.Node>} nodes The list of nodes.
+ * @param {!Array<cvox.SemanticTree.Node>} nodes The list of nodes.
  * @param {!cvox.SemanticTree.Node} root Initial tree.
  * @param {!cvox.SemanticTree.Node} lastop Last operator that has not been
  * processed yet.
- * @param {Array.<cvox.SemanticTree.Node>=} prefixes Operator nodes that will
+ * @param {Array<cvox.SemanticTree.Node>=} prefixes Operator nodes that will
  * become prefix operation (or postfix in case they come after last operand).
  * @return {!cvox.SemanticTree.Node} The root node of the syntax tree.
  * @private
  */
 cvox.SemanticTree.prototype.makeOperationsTree_ = function(
     nodes, root, lastop, prefixes) {
   prefixes = prefixes || [];
 
   if (nodes.length == 0) {
     // Left over prefixes become postfixes.
@@ skipping 119 matching lines @@
  * Combines delimited expressions in a list of nodes.
  *
  * The basic idea of the heuristic is as follows:
  * 1. Opening and closing delimiters are matched regardless of the actual shape
  *    of the fence. These are turned into fenced nodes.
  * 2. Neutral fences are matched only with neutral fences of the same shape.
  * 3. For a collection of unmatched neutral fences we try to get a maximum
  *    number of matching fences. E.g. || a|b || would be turned into a fenced
  *    node with fences || and content a|b.
  * 4. Any remaining unmatched delimiters are turned into punctuation nodes.
- * @param {!Array.<!cvox.SemanticTree.Node>} nodes The list of nodes.
- * @return {!Array.<!cvox.SemanticTree.Node>} The new list of nodes.
+ * @param {!Array<!cvox.SemanticTree.Node>} nodes The list of nodes.
+ * @return {!Array<!cvox.SemanticTree.Node>} The new list of nodes.
  * @private
  */
 cvox.SemanticTree.prototype.getFencesInRow_ = function(nodes) {
   var partition = cvox.SemanticTree.partitionNodes_(
       nodes, cvox.SemanticTree.attrPred_('type', 'FENCE'));
   var felem = partition.comp.shift();
   return this.processFences_(partition.rel, partition.comp, [], [felem]);
 };
 
 
 /**
  * Recursively processes a list of nodes and combines all the fenced expressions
  * into single nodes. It also processes singular fences, building expressions
  * that are only fenced left or right.
- * @param {!Array.<cvox.SemanticTree.Node>} fences FIFO queue of fence nodes.
- * @param {!Array.<Array.<cvox.SemanticTree.Node>>} content FIFO queue content
+ * @param {!Array<cvox.SemanticTree.Node>} fences FIFO queue of fence nodes.
+ * @param {!Array<Array<cvox.SemanticTree.Node>>} content FIFO queue content
  *     between fences.
- * @param {!Array.<cvox.SemanticTree.Node>} openStack LIFO stack of open fences.
- * @param {!Array.<!Array.<cvox.SemanticTree.Node>>} contentStack LIFO stack of
+ * @param {!Array<cvox.SemanticTree.Node>} openStack LIFO stack of open fences.
+ * @param {!Array<!Array<cvox.SemanticTree.Node>>} contentStack LIFO stack of
  *     content between fences yet to be processed.
- * @return {!Array.<cvox.SemanticTree.Node>} A list of nodes with all fenced
+ * @return {!Array<cvox.SemanticTree.Node>} A list of nodes with all fenced
  *     expressions processed.
  * @private
  */
 cvox.SemanticTree.prototype.processFences_ = function(
   fences, content, openStack, contentStack) {
   // Base case 1: Everything is used up.
   if (fences.length == 0 && openStack.length == 0) {
     return contentStack[0];
     }
   var openPred = cvox.SemanticTree.attrPred_('role', 'OPEN');
@@ skipping 96 matching lines @@
   var fenced = fences.shift();
   cvox.SemanticTree.fenceToPunct_(fenced);
   contentStack.push(contentStack.pop().concat([fenced], content.shift()));
   return this.processFences_(fences, content, openStack, contentStack);
 };
 
 
 // TODO (sorge) The following could be done with linear programming.
 /**
  * Trys to combine neutral fences as much as possible.
- * @param {!Array.<!cvox.SemanticTree.Node>} fences A list of neutral fences.
- * @param {!Array.<!Array.<cvox.SemanticTree.Node>>} content Intermediate
+ * @param {!Array<!cvox.SemanticTree.Node>} fences A list of neutral fences.
+ * @param {!Array<!Array<cvox.SemanticTree.Node>>} content Intermediate
  *     content. Observe that |content| = |fences| - 1
- * @return {!Array.<cvox.SemanticTree.Node>} List of node with fully fenced
+ * @return {!Array<cvox.SemanticTree.Node>} List of node with fully fenced
  *     nodes.
  * @private
  */
 cvox.SemanticTree.prototype.processNeutralFences_ = function(fences, content) {
   if (fences.length == 0) {
     return fences;
   }
   if (fences.length == 1) {
     cvox.SemanticTree.fenceToPunct_(fences[0]);
     return fences;
@@ skipping 18 matching lines @@
 };
 
 
 /**
  * Combines nodes framed by two matching fences using the given content.
  * Example: leftFence: [, rightFence: ], midFences: |, |
  *          content: c1, c2, c3, c4, ... cn
  *          return: [c1 | c2 | c3 ], c4, ... cn
  * @param {!cvox.SemanticTree.Node} leftFence The left fence.
  * @param {!cvox.SemanticTree.Node} rightFence The right fence.
- * @param {!Array.<cvox.SemanticTree.Node>} midFences A list of intermediate
+ * @param {!Array<cvox.SemanticTree.Node>} midFences A list of intermediate
  *     fences.
- * @param {!Array.<!Array.<cvox.SemanticTree.Node>>} content Intermediate
+ * @param {!Array<!Array<cvox.SemanticTree.Node>>} content Intermediate
  *     content. Observe that |content| = |fences| - 1 + k where k >= 0 is the
  *     remainder.
- * @return {!Array.<!Array.<cvox.SemanticTree.Node>>} List of content nodes
+ * @return {!Array<!Array<cvox.SemanticTree.Node>>} List of content nodes
  *     where the first is the fully fenced node wrt. the given left and right
  *     fence.
  * @private
  */
 cvox.SemanticTree.prototype.combineFencedContent_ = function(
     leftFence, rightFence, midFences, content) {
 
   if (midFences.length == 0) {
     var fenced = this.makeHorizontalFencedNode_(
         leftFence, rightFence, content.shift());
@@ skipping 38 matching lines @@
     fence.role = cvox.SemanticAttr.Role.CLOSEFENCE;
     break;
   }
 };
 
 
 /**
  * Create a fenced node.
  * @param {cvox.SemanticTree.Node} ofence Opening fence.
  * @param {cvox.SemanticTree.Node} cfence Closing fence.
- * @param {!Array.<cvox.SemanticTree.Node>} content The content
+ * @param {!Array<cvox.SemanticTree.Node>} content The content
  *     between the fences.
  * @return {!cvox.SemanticTree.Node} The new node.
  * @private
  */
 cvox.SemanticTree.prototype.makeHorizontalFencedNode_ = function(
     ofence, cfence, content) {
   var childNode = this.processRow_(content);
   var newNode = this.makeBranchNode_(
       cvox.SemanticAttr.Type.FENCED, [childNode], [ofence, cfence]);
   if (ofence.role == cvox.SemanticAttr.Role.OPEN) {
     newNode.role = cvox.SemanticAttr.Role.LEFTRIGHT;
   } else {
     newNode.role = ofence.role;
   }
   return newNode;
 };
 
 
 /**
  * Combines sequences of punctuated expressions in a list of nodes.
- * @param {!Array.<cvox.SemanticTree.Node>} nodes The list of nodes.
- * @return {!Array.<cvox.SemanticTree.Node>} The new list of nodes.
+ * @param {!Array<cvox.SemanticTree.Node>} nodes The list of nodes.
+ * @return {!Array<cvox.SemanticTree.Node>} The new list of nodes.
  * @private
  */
 cvox.SemanticTree.prototype.getPunctuationInRow_ = function(nodes) {
   // For now we just make a punctuation node with a particular role. This is
   // similar to an mrow. The only exception are ellipses, which we assume to be
   // in lieu of identifiers.
   // In addition we keep the single punctuation nodes as content.
   var partition = cvox.SemanticTree.partitionNodes_(
       nodes, function(x) {
         return cvox.SemanticTree.attrPred_('type', 'PUNCTUATION')(x) &&
@@ skipping 13 matching lines @@
     if (firstComp.length > 0) {
       newNodes.push(this.processRow_(firstComp));
     }
   }
   return [this.makePunctuatedNode_(newNodes, partition.rel)];
 };
 
 
 /**
  * Create a punctuated node.
- * @param {!Array.<!cvox.SemanticTree.Node>} nodes List of all nodes separated
+ * @param {!Array<!cvox.SemanticTree.Node>} nodes List of all nodes separated
  * by punctuations.
- * @param {!Array.<!cvox.SemanticTree.Node>} punctuations List of all separating
+ * @param {!Array<!cvox.SemanticTree.Node>} punctuations List of all separating
  * punctations. Observe that punctations is a subset of nodes.
  * @return {!cvox.SemanticTree.Node}
  * @private
  */
 cvox.SemanticTree.prototype.makePunctuatedNode_ = function(
     nodes, punctuations) {
   var newNode = this.makeBranchNode_(
       cvox.SemanticAttr.Type.PUNCTUATED, nodes, punctuations);
 
   if (punctuations.length == 1 &&
       nodes[0].type == cvox.SemanticAttr.Type.PUNCTUATION) {
     newNode.role = cvox.SemanticAttr.Role.STARTPUNCT;
   } else if (punctuations.length == 1 &&
       nodes[nodes.length - 1].type == cvox.SemanticAttr.Type.PUNCTUATION) {
     newNode.role = cvox.SemanticAttr.Role.ENDPUNCT;
   } else {
     newNode.role = cvox.SemanticAttr.Role.SEQUENCE;
   }
   return newNode;
 };
 
 
 /**
  * Creates a limit node from a sub/superscript or over/under node if the central
  * element is a big operator. Otherwise it creates the standard elements.
  * @param {string} mmlTag The tag name of the original node.
- * @param {!Array.<!cvox.SemanticTree.Node>} children The children of the
+ * @param {!Array<!cvox.SemanticTree.Node>} children The children of the
  *     original node.
  * @return {!cvox.SemanticTree.Node} The newly created limit node.
  * @private
  */
 cvox.SemanticTree.prototype.makeLimitNode_ = function(mmlTag, children) {
   var center = children[0];
   var isFunction = cvox.SemanticTree.attrPred_('type', 'FUNCTION')(center);
   // TODO (sorge) Put this into a single function.
   var isLimit = cvox.SemanticTree.attrPred_('type', 'LARGEOP')(center) ||
       cvox.SemanticTree.attrPred_('type', 'LIMBOTH')(center) ||
@@ skipping 62 matching lines @@
  * as a functional expressions that consists of a prefix and some arguments.
  * In particular we distinguish four types of functional expressions:
  * - integral: Integral expression.
  * - bigop: A big operator expression like a sum.
  * - prefix: A well defined prefix function such as sin, cos or a limit
  *           functions like lim, max.
  * - simple: An expression consisting of letters that are potentially a function
  *           symbol. If we have an explicit function application symbol
  *           following the expression we turn into a prefix function. Otherwise
  *           we decide heuristically if we could have a function application.
- * @param {!Array.<cvox.SemanticTree.Node>} restNodes The remainder list of
+ * @param {!Array<cvox.SemanticTree.Node>} restNodes The remainder list of
  *     nodes.
- * @param {!Array.<cvox.SemanticTree.Node>=} result The result node list.
- * @return {!Array.<!cvox.SemanticTree.Node>} The fully processed list.
+ * @param {!Array<cvox.SemanticTree.Node>=} result The result node list.
+ * @return {!Array<!cvox.SemanticTree.Node>} The fully processed list.
  * @private
  */
 cvox.SemanticTree.prototype.getFunctionsInRow_ = function(restNodes, result) {
   result = result || [];
   // Base case.
   if (restNodes.length == 0) {
     return result;
   }
   var firstNode = /** @type {!cvox.SemanticTree.Node} */ (restNodes.shift());
   var heuristic = cvox.SemanticTree.classifyFunction_(firstNode, restNodes);
   // First node is not a function node.
   if (!heuristic) {
     result.push(firstNode);
     return this.getFunctionsInRow_(restNodes, result);
   }
   // Combine functions in the rest of the row.
   var processedRest = this.getFunctionsInRow_(restNodes, []);
   var newRest = this.getFunctionArgs_(firstNode, processedRest, heuristic);
   return result.concat(newRest);
 };
 
 
 /**
  * Classifies a function wrt. the heuristic that should be applied.
  * @param {!cvox.SemanticTree.Node} funcNode The node to be classified.
- * @param {!Array.<cvox.SemanticTree.Node>} restNodes The remainder list of
+ * @param {!Array<cvox.SemanticTree.Node>} restNodes The remainder list of
  *     nodes. They can useful to look ahead if there is an explicit function
  *     application. If there is one, it will be destructively removed!
  * @return {!string} The string specifying the heuristic.
  * @private
  */
 cvox.SemanticTree.classifyFunction_ = function(funcNode, restNodes) {
   //  We do not allow double function application. This is not lambda calculus!
   if (funcNode.type == cvox.SemanticAttr.Type.APPL ||
       funcNode.type == cvox.SemanticAttr.Type.BIGOP ||
           funcNode.type == cvox.SemanticAttr.Type.INTEGRAL) {
@@ skipping 41 matching lines @@
     funcNode.role = cvox.SemanticAttr.Role.PREFIXFUNC;
     cvox.SemanticTree.propagatePrefixFunc_(funcNode.childNodes[0]);
   }
 };
 
 
 /**
  * Computes the arguments for a function from a list of nodes depending on the
  * given heuristic.
  * @param {!cvox.SemanticTree.Node} func A function node.
- * @param {!Array.<cvox.SemanticTree.Node>} rest List of nodes to choose
+ * @param {!Array<cvox.SemanticTree.Node>} rest List of nodes to choose
  *     arguments from.
  * @param {string} heuristic The heuristic to follow.
- * @return {!Array.<!cvox.SemanticTree.Node>} The function and the remainder of
+ * @return {!Array<!cvox.SemanticTree.Node>} The function and the remainder of
  *     the rest list.
  * @private
  */
 cvox.SemanticTree.prototype.getFunctionArgs_ = function(func, rest, heuristic) {
   switch (heuristic) {
     case 'integral':
     var components = this.getIntegralArgs_(rest);
     var integrand = this.processRow_(components.integrand);
     var funcNode = this.makeIntegralNode_(func, integrand, components.intvar);
     components.rest.unshift(funcNode);
@@ skipping 36 matching lines @@
     }
     rest.unshift(func);
     return rest;
     break;
   }
 };
 
 
 /**
  * Tail recursive function to obtain integral arguments.
- * @param {!Array.<cvox.SemanticTree.Node>} nodes List of nodes to take
+ * @param {!Array<cvox.SemanticTree.Node>} nodes List of nodes to take
  * arguments from.
- * @param {Array.<cvox.SemanticTree.Node>=} args List of integral arguments.
- * @return {{integrand: !Array.<cvox.SemanticTree.Node>,
+ * @param {Array<cvox.SemanticTree.Node>=} args List of integral arguments.
+ * @return {{integrand: !Array<cvox.SemanticTree.Node>,
  *     intvar: cvox.SemanticTree.Node,
- *     rest: !Array.<cvox.SemanticTree.Node>}}
+ *     rest: !Array<cvox.SemanticTree.Node>}}
  *     Result split into integrand, integral variable and the remaining
  *     elements.
  * @private
  */
 cvox.SemanticTree.prototype.getIntegralArgs_ = function(nodes, args) {
   args = args || [];
   if (nodes.length == 0) {
     return {integrand: args, intvar: null, rest: nodes};
   }
   var firstNode = nodes[0];
@@ skipping 156 matching lines @@
  * @private
  */
 cvox.SemanticTree.generalFunctionBoundary_ = function(node) {
   return cvox.SemanticTree.attrPred_('type', 'RELATION')(node) ||
       cvox.SemanticTree.attrPred_('type', 'PUNCTUATION')(node);
 };
 
 
 /**
  * Rewrites tables into matrices or case statements in a list of nodes.
- * @param {!Array.<cvox.SemanticTree.Node>} nodes List of nodes to rewrite.
- * @return {!Array.<cvox.SemanticTree.Node>} The new list of nodes.
+ * @param {!Array<cvox.SemanticTree.Node>} nodes List of nodes to rewrite.
+ * @return {!Array<cvox.SemanticTree.Node>} The new list of nodes.
  * @private
  */
 cvox.SemanticTree.prototype.processTablesInRow_ = function(nodes) {
   // First we process all matrices:
   var partition = cvox.SemanticTree.partitionNodes_(
       nodes, cvox.SemanticTree.tableIsMatrixOrVector_);
   var result = [];
   for (var i = 0, matrix; matrix = partition.rel[i]; i++) {
     result = result.concat(partition.comp.shift());
     result.push(this.tableToMatrixOrVector_(matrix));
@@ skipping 59 matching lines @@
     cvox.SemanticTree.assignRoleToRow_(row, cvox.SemanticAttr.Role[type]);
   }
   return matrix;
 };
 
 
 /**
  * Heuristic to decide if we have a case statement: An expression with a
  * singular open fence before it.
  * @param {!cvox.SemanticTree.Node} table A table node.
- * @param {!Array.<cvox.SemanticTree.Node>} prevNodes A list of previous nodes.
+ * @param {!Array<cvox.SemanticTree.Node>} prevNodes A list of previous nodes.
  * @return {boolean} True if we believe we have a case statement.
  * @private
  */
 cvox.SemanticTree.tableIsCases_ = function(table, prevNodes) {
   return prevNodes.length > 0 &&
       cvox.SemanticTree.attrPred_('role', 'OPENFENCE')(
           prevNodes[prevNodes.length - 1]);
 };
 
 
@@ skipping 86 matching lines @@
       if (cellPred(cell)) {
         cell.role = role;
       }
     });
   }
 };
 
 
 /**
  * Splits a list of nodes wrt. to a given predicate.
- * @param {Array.<cvox.SemanticTree.Node>} nodes A list of nodes.
+ * @param {Array<cvox.SemanticTree.Node>} nodes A list of nodes.
  * @param {!function(cvox.SemanticTree.Node): boolean} pred Predicate for the
  *    partitioning relation.
  * @param {boolean=} reverse If true slicing is done from the end.
- * @return {{head: !Array.<cvox.SemanticTree.Node>,
+ * @return {{head: !Array<cvox.SemanticTree.Node>,
  *           div: cvox.SemanticTree.Node,
- *           tail: !Array.<cvox.SemanticTree.Node>}} The split list.
+ *           tail: !Array<cvox.SemanticTree.Node>}} The split list.
  * @private
  */
 cvox.SemanticTree.sliceNodes_ = function(nodes, pred, reverse) {
   if (reverse) {
     nodes.reverse();
   }
   var head = [];
   for (var i = 0, node; node = nodes[i]; i++) {
     if (pred(node)) {
       if (reverse) {
@@ skipping 10 matching lines @@
   if (reverse) {
     return {head: [], div: null, tail: head.reverse()};
   }
   return {head: head, div: null, tail: []};
 };
 
 
 /**
  * Partitions a list of nodes wrt. to a given predicate. Effectively works like
  * a PER on the ordered set of nodes.
- * @param {!Array.<!cvox.SemanticTree.Node>} nodes A list of nodes.
+ * @param {!Array<!cvox.SemanticTree.Node>} nodes A list of nodes.
  * @param {!function(cvox.SemanticTree.Node): boolean} pred Predicate for the
  *    partitioning relation.
- * @return {{rel: !Array.<cvox.SemanticTree.Node>,
- *           comp: !Array.<!Array.<cvox.SemanticTree.Node>>}}
+ * @return {{rel: !Array<cvox.SemanticTree.Node>,
+ *           comp: !Array<!Array<cvox.SemanticTree.Node>>}}
  *    The partitioning given in terms of a collection of elements satisfying
  *    the predicate and a collection of complementary sets lying inbetween the
  *    related elements. Observe that we always have |comp| = |rel| + 1.
  *
  * Example: On input [a, r_1, b, c, r_2, d, e, r_3] where P(r_i) holds, we
  *    get as output: {rel: [r_1, r_2, r_3], comp: [[a], [b, c], [d, e], []].
  * @private
  */
 cvox.SemanticTree.partitionNodes_ = function(nodes, pred) {
   var restNodes = nodes;
@@ skipping 23 matching lines @@
   var getAttr = function(prop) {
     switch (prop) {
       case 'type': return cvox.SemanticAttr.Type[attr];
       case 'role': return cvox.SemanticAttr.Role[attr];
       case 'font': return cvox.SemanticAttr.Font[attr];
     }
   };
 
   return function(node) {return node[prop] == getAttr(prop);};
 };