Java Node.setLineno方法代码示例

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
@Override
Node processCatchClause(CatchClause clauseNode) {
  AstNode catchVar = clauseNode.getVarName();
  Node node = new Node(Token.CATCH, transform(catchVar));
  if (clauseNode.getCatchCondition() != null) {
    node.addChildToBack(transform(clauseNode.getCatchCondition()));
  } else {
    Node catchCondition = new Node(Token.EMPTY);
    // Old Rhino used the position of the catchVar as the position
    // for the (nonexistent) error being caught.
    catchCondition.setLineno(catchVar.getLineno());
    int clauseAbsolutePosition =
        position2charno(catchVar.getAbsolutePosition());
    catchCondition.setCharno(clauseAbsolutePosition);
    node.addChildToBack(catchCondition);
  }
  node.addChildToBack(transform(clauseNode.getBody()));
  return node;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
@Override
Node processInfixExpression(InfixExpression exprNode) {
  Node n =  new Node(
      transformTokenType(exprNode.getType()),
      transform(exprNode.getLeft()),
      transform(exprNode.getRight()));
  // Set the line number here so we can fine-tune it in ways transform
  // doesn't do.
  n.setLineno(exprNode.getLineno());
  // Position in new ASTNode is to start of expression, but old-fashioned
  // line numbers from Node reference the operator token.  Add the offset
  // to the operator to get the correct character number.
  n.setCharno(position2charno(exprNode.getAbsolutePosition() +
      exprNode.getOperatorPosition()));
  return n;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
private Node transform(AstNode node) {
  String jsDoc = node.getJsDoc();
  NodeWithJsDoc nodeWithJsDoc = null;
  if (jsDoc != null) {
    nodeWithJsDoc = new NodeWithJsDoc();
    nodesWithJsDoc.put(jsDoc, nodeWithJsDoc);
  }

  Node irNode = justTransform(node);
  if (nodeWithJsDoc != null) {
    nodeWithJsDoc.node = irNode;
  }

  // If we have a named function, set the position to that of the name.
  if (irNode.getType() == Token.FUNCTION &&
      irNode.getFirstChild().getLineno() != -1) {
    irNode.setLineno(irNode.getFirstChild().getLineno());
    irNode.setCharno(irNode.getFirstChild().getCharno());
  } else {
    if (irNode.getLineno() == -1) {
      // If we didn't already set the line, then set it now.  This avoids
      // cases like ParenthesizedExpression where we just return a previous
      // node, but don't want the new node to get its parent's line number.
      int lineno = node.getLineno();
      irNode.setLineno(lineno);
      int charno = position2charno(node.getAbsolutePosition());
      irNode.setCharno(charno);
    }
  }
  return irNode;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
@Override
Node processFunctionCall(FunctionCall callNode) {
  Node node = new Node(transformTokenType(callNode.getType()),
                       transform(callNode.getTarget()));
  for (AstNode child : callNode.getArguments()) {
    node.addChildToBack(transform(child));
  }

  int leftParamPos = callNode.getAbsolutePosition() + callNode.getLp();
  node.setLineno(callNode.getLineno());
  node.setCharno(position2charno(leftParamPos));
  return node;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
@Override
Node processRegExpLiteral(RegExpLiteral literalNode) {
  Node literalStringNode = Node.newString(literalNode.getValue());
  // assume it's on the same line.
  literalStringNode.setLineno(literalNode.getLineno());
  Node node = new Node(Token.REGEXP, literalStringNode);
  String flags = literalNode.getFlags();
  if (flags != null && !flags.isEmpty()) {
    Node flagsNode = Node.newString(flags);
    // Assume the flags are on the same line as the literal node.
    flagsNode.setLineno(literalNode.getLineno());
    node.addChildToBack(flagsNode);
  }
  return node;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
@Override
Node processTryStatement(TryStatement statementNode) {
  Node node = new Node(Token.TRY, transform(statementNode.getTryBlock()));
  Node block = new Node(Token.BLOCK);
  boolean lineSet = false;

  for (CatchClause cc : statementNode.getCatchClauses()) {
    // Mark the enclosing block at the same line as the first catch
    // clause.
    if (lineSet == false) {
        block.setLineno(cc.getLineno());
        lineSet = true;
    }
    block.addChildToBack(transform(cc));
  }
  node.addChildToBack(block);

  AstNode finallyBlock = statementNode.getFinallyBlock();
  if (finallyBlock != null) {
    node.addChildToBack(transform(finallyBlock));
  }

  // If we didn't set the line on the catch clause, then
  // we've got an empty catch clause.  Set its line to be the same
  // as the finally block (to match Old Rhino's behavior.)
  if ((lineSet == false) && (finallyBlock != null)) {
    block.setLineno(finallyBlock.getLineno());
  }

  return node;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
@Override
Node processVariableInitializer(VariableInitializer initializerNode) {
  Node node = transform(initializerNode.getTarget());
  if (initializerNode.getInitializer() != null) {
    node.addChildToBack(transform(initializerNode.getInitializer()));
    node.setLineno(node.getLineno());
  }
  return node;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
@Override
Node processFunctionNode(FunctionNode functionNode) {
    Name name = functionNode.getFunctionName();
    Boolean isUnnamedFunction = false;
    if (name == null) {
      name = new Name();
      name.setIdentifier("");
      isUnnamedFunction = true;
    }
    Node node = new com.google.javascript.rhino.FunctionNode(
        name.getIdentifier());
    node.putProp(Node.SOURCENAME_PROP, functionNode.getSourceName());
    Node newName = transform(name);
    if (isUnnamedFunction) {
      // Old Rhino tagged the empty name node with the line number of the
      // declaration.
      newName.setLineno(functionNode.getLineno());
      // TODO(user) Mark line number of paren correctly.
      // Same problem as below - the left paren might not be on the
      // same line as the function keyword.
      int lpColumn = functionNode.getAbsolutePosition() +
          functionNode.getLp();
      newName.setCharno(position2charno(lpColumn));
    }

    node.addChildToBack(newName);
    Node lp = new Node(Token.LP);
    // The left paren's complicated because it's not represented by an
    // AstNode, so there's nothing that has the actual line number that it
    // appeared on.  We know the paren has to appear on the same line as the
    // function name (or else a semicolon will be inserted.)  If there's no
    // function name, assume the paren was on the same line as the function.
    // TODO(user): Mark line number of paren correctly.
    Name fnName = functionNode.getFunctionName();
    if (fnName != null) {
      lp.setLineno(fnName.getLineno());
    } else {
      lp.setLineno(functionNode.getLineno());
    }
    int lparenCharno = functionNode.getLp() +
        functionNode.getAbsolutePosition();

    lp.setCharno(position2charno(lparenCharno));
    for (AstNode param : functionNode.getParams()) {
      lp.addChildToBack(transform(param));
    }
    node.addChildToBack(lp);

    Node bodyNode = transform(functionNode.getBody());
    parseDirectives(bodyNode);
    node.addChildToBack(bodyNode);
   return node;
  }