import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
/**
 * Annotate optional and var_arg function parameters.
 */
private void annotateFunctions(Node n, Node parent) {
  JSDocInfo fnInfo = NodeUtil.getFunctionInfo(n);

  // Compute which function parameters are optional and
  // which are var_args.
  Node args = n.getFirstChild().getNext();
  for (Node arg = args.getFirstChild();
       arg != null;
       arg = arg.getNext()) {
    String argName = arg.getString();
    JSTypeExpression typeExpr = fnInfo == null ?
        null : fnInfo.getParameterType(argName);

    if (convention.isOptionalParameter(arg) ||
        typeExpr != null && typeExpr.isOptionalArg()) {
      arg.putBooleanProp(Node.IS_OPTIONAL_PARAM, true);
    }
    if (convention.isVarArgsParameter(arg) ||
        typeExpr != null && typeExpr.isVarArgs()) {
      arg.putBooleanProp(Node.IS_VAR_ARGS_PARAM, true);
    }
  }
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  switch (n.getToken()) {
    case VAR:
    case LET:
    case CONST:
      if (n.getJSDocInfo() == null || n.getJSDocInfo().getEnumParameterType() == null) return;
      JSTypeExpression enumExp = n.getJSDocInfo().getEnumParameterType();
      if (!enumExp.getRoot().isString()) return;
      String enumTypeStr = enumExp.getRoot().getString();
      if (!enumTypeStr.equals("number") && !enumTypeStr.equals("string")) return;

      Node name = n.getFirstChild().detach();
      Node members = name.getFirstChild().detach();

      Node enumMembers = transformMembers(members, enumTypeStr.equals("number"));
      Node enumNode = new Node(Token.ENUM, name, enumMembers);
      parent.replaceChild(n, enumNode);
      compiler.reportChangeToEnclosingScope(parent);
      break;
    default:
      break;
  }
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
private void maybeSetInlineTypeExpression(
    Node nameNode, Node commentNode, JSDocInfo docInfo, boolean isReturnType) {
  if (docInfo == null) {
    return;
  }
  JSTypeExpression type = docInfo.getType();
  if (type == null) {
    return;
  }
  setTypeExpression(nameNode, type, isReturnType);
  // Remove the part of comment that sets the inline type.
  String toRemove = docInfo.getOriginalCommentString();
  String nodeComment = nodeComments.getComment(commentNode);
  if (nodeComment == null) {
    return;
  }
  nodeComment = nodeComment.replaceFirst("\\n?" + Pattern.quote(toRemove), "");
  nodeComments.setComment(commentNode, nodeComment);
  compiler.reportChangeToEnclosingScope(commentNode);
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
public void testInterfaceMultiExtends2() throws Exception {
  JSDocInfo jsdoc = parse(
      " * @extends {Extended1} \n" +
      " * @interface \n" +
      " * @extends {Extended2} \n" +
      " * @extends {Extended3} */");
  assertTrue(jsdoc.isInterface());
  assertNull(jsdoc.getBaseType());
  assertEquals(3, jsdoc.getExtendedInterfacesCount());
  List<JSTypeExpression> types = jsdoc.getExtendedInterfaces();
  assertTypeEquals(registry.createNamedType("Extended1", null, -1, -1),
     types.get(0));
  assertTypeEquals(registry.createNamedType("Extended2", null, -1, -1),
      types.get(1));
  assertTypeEquals(registry.createNamedType("Extended3", null, -1, -1),
      types.get(2));
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
/** Return declared JSDoc type for the given name declaration, or null if none present. */
@Nullable
public static JSTypeExpression getDeclaredTypeExpression(Node declaration) {
  checkArgument(declaration.isName() || declaration.isStringKey());
  JSDocInfo nameJsdoc = getBestJSDocInfo(declaration);
  if (nameJsdoc != null) {
    return nameJsdoc.getType();
  }
  Node parent = declaration.getParent();
  if (parent.isRest() || parent.isDefaultValue()) {
    parent = parent.getParent();
  }
  if (parent.isParamList()) {
    JSDocInfo functionJsdoc = getBestJSDocInfo(parent.getParent());
    if (functionJsdoc != null) {
      return functionJsdoc.getParameterType(declaration.getString());
    }
  }
  return null;
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
/** @return The proper constructor doc for the Polymer call. */
private JSDocInfoBuilder getConstructorDoc(final PolymerClassDefinition cls) {
  JSDocInfoBuilder constructorDoc = JSDocInfoBuilder.maybeCopyFrom(cls.constructor.info);
  constructorDoc.recordConstructor();

  JSTypeExpression baseType = new JSTypeExpression(
      new Node(Token.BANG, IR.string(PolymerPassStaticUtils.getPolymerElementType(cls))),
      PolymerPass.VIRTUAL_FILE);
  constructorDoc.recordBaseType(baseType);

  String interfaceName = getInterfaceName(cls);
  JSTypeExpression interfaceType = new JSTypeExpression(
      new Node(Token.BANG, IR.string(interfaceName)), PolymerPass.VIRTUAL_FILE);
  constructorDoc.recordImplementedInterface(interfaceType);

  return constructorDoc;
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
/**
 * Appends all properties in the ClassDefinition to the prototype of the custom element.
 */
private void appendPropertiesToBlock(
    final PolymerClassDefinition cls, Node block, String basePath) {
  for (MemberDefinition prop : cls.props) {
    Node propertyNode = IR.exprResult(
        NodeUtil.newQName(compiler, basePath + prop.name.getString()));

    // If a property string is quoted, make sure the added prototype properties are also quoted
    if (prop.name.isQuotedString()) {
      continue;
    }

    propertyNode.useSourceInfoIfMissingFromForTree(prop.name);
    JSDocInfoBuilder info = JSDocInfoBuilder.maybeCopyFrom(prop.info);

    JSTypeExpression propType = PolymerPassStaticUtils.getTypeFromProperty(prop, compiler);
    if (propType == null) {
      return;
    }
    info.recordType(propType);
    propertyNode.getFirstChild().setJSDocInfo(info.build());

    block.addChildToBack(propertyNode);
  }
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
private void addGetterExport(
    Node script, Node forSourceInfo, Node objLit, String exportedName, String localName) {
  // Type checker doesn't infer getters so mark the return as unknown.
  // { /** @return {?} */ get foo() { return foo; } }
  Node getter = Node.newString(Token.GETTER_DEF, exportedName);
  getter.putBooleanProp(Node.MODULE_EXPORT, true);
  objLit.addChildToBack(getter);

  Node name = NodeUtil.newQName(compiler, localName);
  Node function = IR.function(IR.name(""), IR.paramList(), IR.block(IR.returnNode(name)));
  getter.addChildToFront(function);

  JSDocInfoBuilder builder = new JSDocInfoBuilder(true);
  builder.recordReturnType(
      new JSTypeExpression(new Node(Token.QMARK), script.getSourceFileName()));
  getter.setJSDocInfo(builder.build());

  getter.useSourceInfoIfMissingFromForTree(forSourceInfo);
  compiler.reportChangeToEnclosingScope(getter.getFirstChild().getLastChild());
  compiler.reportChangeToEnclosingScope(getter);
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
/**
 * @param node A getter or setter node.
 */
@Nullable
private JSTypeExpression getTypeFromGetterOrSetter(Node node) {
  JSDocInfo info = node.getJSDocInfo();
  if (info != null) {
    boolean getter = node.isGetterDef() || node.getBooleanProp(Node.COMPUTED_PROP_GETTER);
    if (getter && info.getReturnType() != null) {
      return info.getReturnType();
    } else {
      Set<String> paramNames = info.getParameterNames();
      if (paramNames.size() == 1) {
        JSTypeExpression paramType =
            info.getParameterType(Iterables.getOnlyElement(info.getParameterNames()));
        if (paramType != null) {
          return paramType;
        }
      }
    }
  }

  return null;
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
/**
 * Handles transpilation of a standard class member function. Getters, setters, and the
 * constructor are not handled here.
 */
private void visitMethod(Node member, ClassDeclarationMetadata metadata) {
  Node qualifiedMemberAccess = getQualifiedMemberAccess(
      member,
      NodeUtil.newQName(compiler, metadata.fullClassName),
      NodeUtil.newQName(compiler, metadata.fullClassName + ".prototype"));
  Node method = member.getLastChild().detach();

  Node assign = IR.assign(qualifiedMemberAccess, method);
  assign.useSourceInfoIfMissingFromForTree(member);

  JSDocInfo info = member.getJSDocInfo();
  if (member.isStaticMember() && NodeUtil.referencesThis(assign.getLastChild())) {
    JSDocInfoBuilder memberDoc = JSDocInfoBuilder.maybeCopyFrom(info);
    memberDoc.recordThisType(
        new JSTypeExpression(new Node(Token.BANG, new Node(Token.QMARK)),
        member.getSourceFileName()));
    info = memberDoc.build();
  }
  if (info != null) {
    assign.setJSDocInfo(info);
  }

  Node newNode = NodeUtil.newExpr(assign);
  metadata.insertNodeAndAdvance(newNode);
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
private void visitTypeAlias(NodeTraversal t, Node n, Node parent) {
  String alias = n.getString();
  if (t.getScope().isDeclared(alias, true)) {
    compiler.report(
        JSError.make(n, TYPE_ALIAS_ALREADY_DECLARED, alias));
  }
  JSDocInfoBuilder builder = JSDocInfoBuilder.maybeCopyFrom(n.getJSDocInfo());
  builder.recordTypedef(new JSTypeExpression(
      convertWithLocation(n.getFirstChild()), n.getSourceFileName()));

  Node newName =
      maybeGetQualifiedNameNode(IR.name(n.getString())).useSourceInfoIfMissingFromForTree(n);
  Node newDec1 = NodeUtil.newQNameDeclaration(
      compiler,
      newName.getQualifiedName(),
      null,
      builder.build()).useSourceInfoFromForTree(n);
  parent.replaceChild(n, newDec1);
  t.reportCodeChange();
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的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);
    }
  }
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
private void maybeAddJsDocUsages(NodeTraversal t, Node n) {
  JSDocInfo info = n.getJSDocInfo();
  if (info == null) {
    return;
  }

  if (declaresFunctionOrClass(n)) {
    for (JSTypeExpression expr : info.getImplementedInterfaces()) {
      maybeAddUsage(t, n, expr);
    }
    if (info.getBaseType() != null) {
      maybeAddUsage(t, n, info.getBaseType());
    }
    for (JSTypeExpression extendedInterface : info.getExtendedInterfaces()) {
      maybeAddUsage(t, n, extendedInterface);
    }
  }

  for (Node typeNode : info.getTypeNodes()) {
    maybeAddWeakUsage(t, n, typeNode);
  }
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
/**
 * Parse a description as a {@code @type}.
 */
public JSDocInfo parseInlineTypeDoc() {
  skipEOLs();

  JsDocToken token = next();
  int lineno = stream.getLineno();
  int startCharno = stream.getCharno();
  Node typeAst = parseParamTypeExpression(token);
  recordTypeNode(lineno, startCharno, typeAst, token == JsDocToken.LEFT_CURLY);

  JSTypeExpression expr = createJSTypeExpression(typeAst);
  if (expr != null) {
    jsdocBuilder.recordType(expr);
    jsdocBuilder.recordInlineType();
    return retrieveAndResetParsedJSDocInfo();
  }
  return null;
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
private ImmutableSet<NominalType> getInterfacesHelper(
    JSDocInfo jsdoc, DeclaredTypeRegistry registry,
    ImmutableList<String> typeParameters, boolean implementedIntfs) {
  ImmutableSet.Builder<NominalType> builder = ImmutableSet.builder();
  for (JSTypeExpression texp : (implementedIntfs ?
      jsdoc.getImplementedInterfaces() :
      jsdoc.getExtendedInterfaces())) {
    Node expRoot = texp.getRoot();
    JSType interfaceType = getTypeFromComment(expRoot, registry, typeParameters);
    NominalType nt = interfaceType.getNominalTypeIfSingletonObj();
    if (nt != null && nt.isInterface()) {
      builder.add(nt);
    } else if (implementedIntfs) {
      warnings.add(JSError.make(
          expRoot, IMPLEMENTS_NON_INTERFACE, interfaceType.toString()));
    } else {
      warnings.add(JSError.make(
          expRoot, EXTENDS_NON_INTERFACE, interfaceType.toString()));
    }
  }
  return builder.build();
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
private void fillInReturnType(
    JSDocInfo jsdoc, Node funNode, Node parent,
    ImmutableList<String> typeParameters,
    DeclaredTypeRegistry registry, FunctionTypeBuilder builder,
    boolean ignoreJsdoc /* for when the jsdoc is malformed */) {
  JSDocInfo inlineRetJsdoc = ignoreJsdoc || !funNode.isFunction()
      ? null : funNode.getFirstChild().getJSDocInfo();
  JSTypeExpression retTypeExp = jsdoc == null ? null : jsdoc.getReturnType();
  if (parent.isSetterDef() && retTypeExp == null) {
    // inline returns for getters/setters are not parsed
    builder.addRetType(this.commonTypes.UNDEFINED);
  } else if (inlineRetJsdoc != null) {
    builder.addRetType(
        getDeclaredTypeOfNode(inlineRetJsdoc, registry, typeParameters));
    if (retTypeExp != null) {
      warnings.add(JSError.make(funNode, TWO_JSDOCS, "the return type"));
    }
  } else {
    builder.addRetType(
        getTypeFromJSTypeExpression(retTypeExp, registry, typeParameters));
  }
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
public void testInterfaceMultiExtends2() {
  JSDocInfo jsdoc = parse(
      " * @extends {Extended1} \n" +
      " * @interface \n" +
      " * @extends {Extended2} \n" +
      " * @extends {Extended3} */");
  assertThat(jsdoc.isInterface()).isTrue();
  assertThat(jsdoc.getBaseType()).isNull();
  assertThat(jsdoc.getExtendedInterfacesCount()).isEqualTo(3);
  List<JSTypeExpression> types = jsdoc.getExtendedInterfaces();
  assertTypeEquals(registry.createNamedType("Extended1", null, -1, -1),
     types.get(0));
  assertTypeEquals(registry.createNamedType("Extended2", null, -1, -1),
      types.get(1));
  assertTypeEquals(registry.createNamedType("Extended3", null, -1, -1),
      types.get(2));
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
/**
 * Changes the JS Doc Type of the given node.
 */
public Builder changeJsDocType(Node n, AbstractCompiler compiler, String type) {
  Node typeNode = JsDocInfoParser.parseTypeString(type);
  Preconditions.checkNotNull(typeNode, "Invalid type: %s", type);
  JSTypeExpression typeExpr = new JSTypeExpression(typeNode, "jsflume");
  JSType newJsType = typeExpr.evaluate(null, compiler.getTypeRegistry());
  if (newJsType == null) {
    throw new RuntimeException("JS Compiler does not recognize type: " + type);
  }

  // TODO(mknichel): Use the JSDocInfoParser to find the end of the type declaration. This
  // would also handle multiple lines, and record types (which contain '{')

  // Only "@type" allows type names without "{}"
  replaceTypePattern(n, type, Pattern.compile(
      "@(type) *\\{?[^@\\s}]+\\}?"));

  // Text following other annotations may be a comment, not a type.
  replaceTypePattern(n, type, Pattern.compile(
      "@(export|package|private|protected|public|const|return) *\\{[^}]+\\}"));

  return this;
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
public void testRecordTypes() {
  builder.recordType(new JSTypeExpression(
      JsDocInfoParser.parseTypeString("{foo: number}"), ""));
  JSDocInfo info = builder.buildAndReset();
  assertEquals("/** @type {{foo:number}} */ ", jsDocInfoPrinter.print(info));

  builder.recordType(new JSTypeExpression(
      JsDocInfoParser.parseTypeString("{foo}"), ""));
  info = builder.buildAndReset();
  assertEquals("/** @type {{foo}} */ ", jsDocInfoPrinter.print(info));

  builder.recordType(new JSTypeExpression(
      JsDocInfoParser.parseTypeString("{foo, bar}"), ""));
  info = builder.buildAndReset();
  assertEquals("/** @type {{foo,bar}} */ ", jsDocInfoPrinter.print(info));

  builder.recordType(new JSTypeExpression(
      JsDocInfoParser.parseTypeString("{foo: number, bar}"), ""));
  info = builder.buildAndReset();
  assertEquals("/** @type {{foo:number,bar}} */ ", jsDocInfoPrinter.print(info));

  builder.recordType(new JSTypeExpression(
      JsDocInfoParser.parseTypeString("{foo, bar: number}"), ""));
  info = builder.buildAndReset();
  assertEquals("/** @type {{foo,bar:number}} */ ", jsDocInfoPrinter.print(info));
}
 

import com.google.javascript.rhino.JSTypeExpression; //导入依赖的package包/类
public void testParseImplementsGenerics() throws Exception {
  // we ignore things inside <> for now
  List<JSTypeExpression> interfaces =
      parse("@implements {SomeInterface.<*>} */")
      .getImplementedInterfaces();
  assertEquals(1, interfaces.size());
  assertTypeEquals(new NamedType(registry, "SomeInterface", null, -1, -1),
      interfaces.get(0));
}