Java NodeUtil.getName方法代码示例

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包/类
/**
 * Adds a class node to the top level scope.
 *
 * <p>This determines the classname using the nearest available name node.
 */
void addClassToScope(Node n) {
  Preconditions.checkState(n.isClass());
  String className = NodeUtil.getName(n);
  if (className == null) {
    // We do not emit an error here as there can be anonymous classes without names.
    return;
  }
  addTypeToScope(n, className);
}
 

import com.google.javascript.jscomp.NodeUtil; //导入方法依赖的package包/类
private String getEnclosingFunctionName(Node fnNode) {
  if (fnNode.isArrowFunction()) {
    return null;
  }

  // Use the QualifiedName if the function is on an object/namespace: `foo.moreFoo()`;
  // otherwise, use the string on the node: `foo` for `function foo()`
  Node fnParent = fnNode.getParent();
  if (fnParent.isGetProp() || fnParent.isCall()) {
    return NodeUtil.getName(fnNode);
  }

  return fnParent.getString();
}
 

import com.google.javascript.jscomp.NodeUtil; //导入方法依赖的package包/类
private void checkMissingJsDoc(NodeTraversal t, Node function) {
  if (isFunctionThatShouldHaveJsDoc(t, function)) {
    String name = NodeUtil.getName(function);
    // Don't warn for test functions, setUp, tearDown, etc.
    if (name == null || !ExportTestFunctions.isTestFunction(name)) {
      t.report(function, MISSING_JSDOC);
    }
  }
}
 

import com.google.javascript.jscomp.NodeUtil; //导入方法依赖的package包/类
/** Converts @constructor annotated functions into class definitions. */
void convertConstructorToClass(Node n, JSDocInfo jsDoc) {
  Preconditions.checkState(n.isFunction());
  Preconditions.checkState(n.getFirstChild().isName());
  Preconditions.checkState(n.getSecondChild().isParamList());
  Preconditions.checkState(n.getLastChild().isNormalBlock());
  String typeName = NodeUtil.getName(n);
  // Break up function
  Node name = n.getFirstChild();
  Node params = n.getSecondChild();
  Node body = n.getLastChild();
  n.detachChildren();

  // The empty name corresponds to anonymous constructors.
  // The name is usually located in the surrounding context.
  // ie. /** @constructor */ var A = function() {};
  // is converted to: var A = class {};
  if (name.getString().isEmpty()) {
    name = IR.empty();
  }

  // Superclass defaults to empty
  Node superClass = IR.empty();
  if (jsDoc.getBaseType() != null) {
    // Fullname of superclass
    // Closure Compiler generates non-nullable base classes:
    // ie. A.B.C is parsed as !A.B.C
    String superClassName =
        jsDoc
            .getBaseType()
            .getRoot()
            .getFirstChild() // ignore the ! node as we always output non nullable types
            .getString();
    superClass = NodeUtil.newQName(compiler, superClassName);
    superClass.useSourceInfoFrom(n);
  }

  Node typeNode;
  if (jsDoc.isInterface()) {
    List<JSTypeExpression> interfaces = jsDoc.getExtendedInterfaces();
    if (!interfaces.isEmpty()) {
      Node superInterfaces = new Node(Token.INTERFACE_EXTENDS);
      for (JSTypeExpression type : interfaces) {
        superInterfaces.addChildToBack(type.getRoot());
      }
      superClass = superInterfaces;
    }
    typeNode = new Node(Token.INTERFACE, name, superClass, new Node(Token.INTERFACE_MEMBERS));
    typeNode.useSourceInfoFromForTree(n);
    // Must be registered here, as JSCompiler cannot extract names from INTERFACE nodes.
    addTypeToScope(typeNode, typeName);
  } else {
    // Generate new class node with only a constructor method
    Node constructor =
        IR.memberFunctionDef("constructor", IR.function(IR.name(""), params, body));
    constructor.useSourceInfoFrom(n);
    // Sets jsdoc info to preserve type declarations on method
    constructor.setJSDocInfo(jsDoc);
    Node classMembers = new Node(Token.CLASS_MEMBERS, constructor);
    typeNode = new Node(Token.CLASS, name, superClass, classMembers);
  }

  typeNode.setJSDocInfo(n.getJSDocInfo());
  nodeComments.replaceWithComment(n, typeNode);
}