Java NodeUtil类代码示例

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
/**
 * Move all the child nodes following start in srcParent to the end of
 * destParent's child list.
 * @param start The start point in the srcParent child list.
 * @param srcParent The parent node of start.
 * @param destParent The destination node.
 */
static private void moveAllFollowing(
    Node start, Node srcParent, Node destParent) {
  for (Node n = start.getNext(); n != null; n = start.getNext()) {
    boolean isFunctionDeclaration =
        NodeUtil.isFunctionDeclaration(n);

    srcParent.removeChild(n);

    if (isFunctionDeclaration) {
      destParent.addChildToFront(n);
    } else {
      destParent.addChildToBack(n);
    }
  }
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
private void processVariableAssignment(Component cmp, Node assignmentNode) {
    if (NodeUtil.isLiteralValue(assignmentNode, false)) {
        cmp.setCodeFragment(cmp.name() + " : " + NodeUtil.getStringValue(assignmentNode));
        cmp.setCodeFragment(declarationSnippet(assignmentNode.getToken()));
    } else if (assignmentNode.hasChildren() && assignmentNode.isNew()
            && (assignmentNode.getFirstChild().isName() || assignmentNode.getFirstChild().isGetProp())) {
        String invokedType;
        if (assignmentNode.getFirstChild().isGetProp()) {
            invokedType = assignmentNode.getFirstChild().getFirstChild().getString();
            cmp.insertComponentInvocation(new TypeDeclaration(invokedType));
        } else {
            invokedType = assignmentNode.getFirstChild().getString();
            cmp.insertComponentInvocation(new TypeInstantiation(invokedType));
        }
        cmp.setCodeFragment(invokedType);
    }
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
private void createTypeAlias(Node n, Node parent) {
  JSDocInfo bestJSDocInfo = NodeUtil.getBestJSDocInfo(n);
  if (bestJSDocInfo != null && bestJSDocInfo.hasTypedefType()) {
    String name;
    switch (n.getToken()) {
      case NAME:
        name = n.getString();
        break;
      case GETPROP:
        // Inner typedef
        name = n.getSecondChild().getString();
        break;
      default:
        name = n.getFirstChild().getString();
        break;
    }
    Node typeDef = Node.newString(Token.TYPE_ALIAS, name);
    types.put(name, typeDef);
    typeDef.setJSDocInfo(bestJSDocInfo);
    replaceExpressionOrAssignment(n, parent, typeDef);
  }
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
/**
 * Check if we can safely generate a field initializer. We don't do this if the assignment rhs is
 * not a literal or the enclosing function is not a constructor.
 */
private boolean canPromoteFieldInitializer(ClassMemberDeclaration declaration) {
  if (!NodeUtil.isLiteralValue(declaration.rhs, false)) {
    return false;
  }

  Node fnNode = NodeUtil.getEnclosingFunction(declaration.exprRoot);
  if (fnNode != null) {
    String fnName = getEnclosingFunctionName(fnNode);
    if (!"constructor".equals(fnName)) {
      return false;
    }
  }

  return true;
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
/**
 * Factory method for creating a new ClassMemberDeclarationOnThis on a declaration internal to a
 * class via the "this" keyword.
 *
 * <ul>
 *   <li>{@code this.a = 5}
 *   <li>{@code this.b}
 * </ul>
 *
 * Returns null if the expression node is an invalid member declaration.
 */
@Nullable
static ClassMemberDeclaration newDeclarationOnThis(Node n) {
  Node fullName = getFullName(n);
  // Node MUST start with "this." and be shallow, i.e. "this.foo".
  // "this.foo.bar" and other nestings are not declarations and are ignored.
  // fullName is a binary tree and multiple parts are represented by GETPROP
  // nodes recursively on the left (first) child, so a first child of THIS is
  // sufficient to ensure the name is of the form "this.foo".
  if (!fullName.isGetProp() || !fullName.getFirstChild().isThis()) {
    return null;
  }

  Node classNode = NodeUtil.getEnclosingClass(n);
  String memberName = fullName.getLastChild().getString();
  if (classNode == null) {
    return null;
  }

  return new ClassMemberDeclaration(n, false, classNode, memberName);
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
private void maybeAddProvidesExport(Node exportsName) {
  String fullname = exportsName.getQualifiedName();

  if (providesObjectChildren.containsKey(fullname)) {
    googProvideNamespaceToNode.put(fullname, exportsName);
    addExport(fullname, fullname, nameUtil.lastStepOfName(exportsName));

  } else if (exportsName.isGetProp()
      && providesObjectChildren.containsKey(exportsName.getFirstChild().getQualifiedName())) {
    googProvideNamespaceToNode.put(fullname, exportsName);

    // functions declared on functions should be exported.
    // static functions on classes should not be exported.
    String parentName = exportsName.getFirstChild().getQualifiedName();
    @Nullable Node parentNode = googProvideNamespaceToNode.get(parentName);
    JSDocInfo jsDoc = parentNode != null ? NodeUtil.getBestJSDocInfo(parentNode) : null;

    if (providesObjectChildren.containsKey(parentName)
        && (jsDoc == null || !jsDoc.isConstructor())) {
      addExport(fullname, fullname, nameUtil.lastStepOfName(exportsName));
    }
  }
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  JSDocInfo bestJSDocInfo = NodeUtil.getBestJSDocInfo(n);
  if (bestJSDocInfo == null) {
    return;
  }

  // Add visibility for private and protected.
  if (Visibility.PRIVATE.equals(bestJSDocInfo.getVisibility())) {
    n.putProp(Node.ACCESS_MODIFIER, Visibility.PRIVATE);
  } else if (Visibility.PROTECTED.equals(bestJSDocInfo.getVisibility())) {
    n.putProp(Node.ACCESS_MODIFIER, Visibility.PROTECTED);
  }

  // Change variable declarations to constants
  if (bestJSDocInfo.isConstant() && (n.isVar() || n.isLet())) {
    n.setToken(Token.CONST);
  }
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
private void maybeReassignAlias(Node assign) {
  Node lhs = assign.getFirstChild();
  if (!lhs.isGetProp()) {
    // TODO(dpurpura): Add support for GET_ELEM.  (e.g. Foo['abc'])
    return;
  }

  // Find the name of the deepest first child.
  String alias = null;
  for (Node child = lhs; child != null; child = child.getFirstChild()) {
    if (child.isName()) {
      alias = child.getQualifiedName();
    }
  }

  checkNotNull(alias, "Missing name for alias");
  if (aliasToProvidedNamespace.containsKey(alias)) {
    String providedNamespace = aliasToProvidedNamespace.get(alias);

    String suffix = lhs.getQualifiedName().substring(alias.length());
    Node fullName = NodeUtil.newQName(compiler, providedNamespace + suffix);
    assign.replaceChild(lhs, fullName);
  }
  return;
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
static JSDocInfo getJSDocForRhs(Node rhs, JSDocInfo oldJSDoc) {
  switch (NodeUtil.getKnownValueType(rhs)) {
    case BOOLEAN:
      return getConstJSDoc(oldJSDoc, "boolean");
    case NUMBER:
      return getConstJSDoc(oldJSDoc, "number");
    case STRING:
      return getConstJSDoc(oldJSDoc, "string");
    case NULL:
      return getConstJSDoc(oldJSDoc, "null");
    case VOID:
      return getConstJSDoc(oldJSDoc, "void");
    case OBJECT:
      if (rhs.isRegExp()) {
        return getConstJSDoc(oldJSDoc, new Node(Token.BANG, IR.string("RegExp")));
      }
      break;
    case UNDETERMINED:
      if (oldJSDoc != null && oldJSDoc.getDescription() != null) {
        return getConstJSDoc(oldJSDoc, "string");
      }
      break;
  }
  return null;
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
/**
 * Does two simplifications to const/let/var nodes.
 * 1. Splits them so that each declaration is a separate statement.
 * 2. Removes non-import destructuring statements, which we assume are not type declarations.
 */
static void splitNameDeclarationsAndRemoveDestructuring(Node n, NodeTraversal t) {
  checkArgument(NodeUtil.isNameDeclaration(n));
  while (n.hasChildren()) {
    Node lhsToSplit = n.getLastChild();
    if (lhsToSplit.isDestructuringLhs() && !isImportRhs(lhsToSplit.getLastChild())) {
      // Remove destructuring statements, which we assume are not type declarations
      NodeUtil.markFunctionsDeleted(lhsToSplit, t.getCompiler());
      NodeUtil.removeChild(n, lhsToSplit);
      t.reportCodeChange();
      continue;
    }
    if (n.hasOneChild()) {
      return;
    }
    // A name declaration with more than one LHS is split into separate declarations.
    Node rhs = lhsToSplit.hasChildren() ? lhsToSplit.removeFirstChild() : null;
    Node newDeclaration =
        NodeUtil.newDeclaration(lhsToSplit.detach(), rhs, n.getToken()).srcref(n);
    n.getParent().addChildAfter(newDeclaration, n);
    t.reportCodeChange();
  }
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
private void propagateJsdocAtName(NodeTraversal t, Node nameNode) {
  checkArgument(
      nameNode.isQualifiedName() || nameNode.isStringKey() || nameNode.isDestructuringLhs(),
      nameNode);
  Node jsdocNode = NodeUtil.getBestJSDocInfoNode(nameNode);
  JSDocInfo originalJsdoc = jsdocNode.getJSDocInfo();
  if (!isConstToBeInferred(originalJsdoc, nameNode)) {
    return;
  }
  Node rhs = NodeUtil.getRValueOfLValue(nameNode);
  if (rhs == null) {
    return;
  }
  JSDocInfo newJsdoc = JsdocUtil.getJSDocForRhs(rhs, originalJsdoc);
  if (newJsdoc == null && ClassUtil.isThisProp(nameNode)) {
    Var decl = findNameDeclaration(t.getScope(), rhs);
    newJsdoc = JsdocUtil.getJSDocForName(decl, originalJsdoc);
  }
  if (newJsdoc != null) {
    jsdocNode.setJSDocInfo(newJsdoc);
    t.reportCodeChange();
  }
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
private static String getClassName(Node functionNode) {
  checkArgument(functionNode.isFunction());
  if (isClassMethod(functionNode)) {
    Node parent = functionNode.getParent();
    if (parent.isMemberFunctionDef()) {
      // ES6 class
      Node classNode = functionNode.getGrandparent().getParent();
      checkState(classNode.isClass());
      return NodeUtil.getName(classNode);
    }
    // goog.defineClass
    checkState(parent.isStringKey());
    Node defineClassCall = parent.getGrandparent();
    checkState(defineClassCall.isCall());
    return NodeUtil.getBestLValue(defineClassCall).getQualifiedName();
  }
  return NodeUtil.getName(functionNode);
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
/**
 * @return True if n is a function node which is explicitly annotated
 * as returning a nullable type, other than {?}.
 */
private static boolean isReturnTypeNullable(Node n) {
  if (n == null || !n.isFunction()) {
    return false;
  }
  FunctionTypeI functionType = n.getTypeI().toMaybeFunctionType();
  if (functionType == null) {
    // If the JSDoc declares a non-function type on a function node, we still shouldn't crash.
    return false;
  }
  TypeI returnType = functionType.getReturnType();
  if (returnType == null
      || returnType.isUnknownType() || !returnType.isNullable()) {
    return false;
  }
  JSDocInfo info = NodeUtil.getBestJSDocInfo(n);
  return info != null && info.hasReturnType();
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
private void visitFunction(NodeTraversal t, Node function, Node parent) {
  JSDocInfo jsDoc = NodeUtil.getBestJSDocInfo(function);

  if (jsDoc == null && !hasAnyInlineJsDoc(function)) {
    checkMissingJsDoc(t, function);
  } else {
    if (t.inGlobalScope()
        || hasAnyInlineJsDoc(function)
        || !jsDoc.getParameterNames().isEmpty()
        || jsDoc.hasReturnType()) {
      checkParams(t, function, jsDoc);
    }
    checkReturn(t, function, jsDoc);
  }

  if (parent.isMemberFunctionDef()
      && "constructor".equals(parent.getString())
      && jsDoc != null
      && !jsDoc.getVisibility().equals(Visibility.INHERITED)) {
    t.report(function, CONSTRUCTOR_DISALLOWED_JSDOC);
  }
}
 

import com.google.javascript.jscomp.NodeUtil; //导入依赖的package包/类
/**
 * Checks that the inline type annotations are correct.
 */
private void checkInlineParams(NodeTraversal t, Node function) {
  Node paramList = NodeUtil.getFunctionParameters(function);

  for (Node param : paramList.children()) {
    JSDocInfo jsDoc = param.getJSDocInfo();
    if (jsDoc == null) {
      t.report(param, MISSING_PARAMETER_JSDOC);
      return;
    } else {
      JSTypeExpression paramType = jsDoc.getType();
      checkNotNull(paramType, "Inline JSDoc info should always have a type");
      checkParam(t, param, null, paramType);
    }
  }
}