Java Code Examples for com.google.javascript.rhino.Node#isClass()

private Iterable<Function.Detail> buildThrowsData(
    final NominalType context, Node node, JsDoc jsDoc) {
  if (node.isClass()) {
    final JSDocInfo info = findClassConstructorDocs(node);
    if (info != null) {
      jsDoc = JsDoc.from(info);
    }
  }
  final LinkFactory contextLinkFactory = linkFactory.withTypeContext(context);
  final TypeExpressionParser typeParser = expressionParserFactory.create(contextLinkFactory);
  return jsDoc
      .getThrowsClauses()
      .stream()
      .map(
          input -> {
            Detail.Builder detail = Detail.newBuilder();

            Comment comment = parser.parseComment(input.getDescription(), contextLinkFactory);
            if (comment.getTokenCount() > 0) {
              detail.setDescription(comment);
            }

            if (input.getType().isPresent()) {
              JSTypeExpression expression = input.getType().get();
              JSType thrownType = evaluate(expression);
              detail.setType(typeParser.parse(thrownType));
            }
            return detail.build();
          })
      .collect(toImmutableList());
}
 

private boolean isTypeDefinition(Node rhs) {
  return rhs.isClass() || rhs.getToken() == Token.INTERFACE;
}
 

private void visitFunctionParameters(
    FunctionType ftype, boolean emitTemplatizedTypes, List<String> alreadyEmittedTemplateType) {
  final boolean shouldEmitThis = shouldEmitThisParam(ftype);
  if (!shouldEmitThis) {
    // alreadyEmittedTemplateType might be an immutable list.
    alreadyEmittedTemplateType = new ArrayList<>(alreadyEmittedTemplateType);
    alreadyEmittedTemplateType.add(ftype.getTypeOfThis().getDisplayName());
  }
  if (emitTemplatizedTypes) {
    visitTemplateTypes(ftype, alreadyEmittedTemplateType, true);
  }
  // When all the parameters to the function are unknown, it might be the
  // case that the function is overriding/implementing a superclass or interface that is in an
  // unseen input.
  // If so, we can't know whether the parameters are optional or not, so mark them optional.
  // This is too broad (we also affect callback types) but we can fix that if it's a problem.
  boolean makeAllParametersOptional = allParametersUnknown(ftype);
  emit("(");
  Iterator<Parameter> parameters = ftype.getParameters().iterator();
  if (shouldEmitThis) {
    emitThisParameter(ftype, parameters);
  }
  Iterator<String> names = null;
  Node functionSource = ftype.getSource();
  if (functionSource != null && functionSource.isClass()) {
    Node members = functionSource.getLastChild();
    for (Node member : members.children()) {
      if (member.isMemberFunctionDef() && member.getString().equals("constructor")) {
        functionSource = member.getOnlyChild();
        break;
      }
    }
  }
  if (functionSource != null && functionSource.isFunction()) {
    // functionSource AST: FUNCTION -> (NAME, PARAM_LIST, BLOCK ...)
    Iterable<Node> parameterNodes = functionSource.getFirstChild().getNext().children();
    // TODO(bradfordcsmith): This will need to be updated when transpilation of default
    //   and destructured parameters stops happening in checks-only compilation.
    names = transform(parameterNodes, (node) -> this.getParameterName(node)).iterator();
  }

  int paramCount = 0;
  while (parameters.hasNext()) {
    Parameter param = parameters.next();
    if (param.isVariadic()) {
      emit("...");
    }

    String pName = "";
    if (names != null && names.hasNext()) {
      pName = names.next();
    }
    if (pName.isEmpty()) {
      // If we cannot find a name for the parameter, just generate one.
      if (paramCount < 26) {
        pName = Character.toString((char) (97 + paramCount));
      } else {
        pName = "p" + (paramCount - 26);
      }
    }
    emitNoSpace(pName);
    paramCount++;

    // In TypeScript ...a?: any[] is illegal, so we can only make non-varargs optional.
    if ((param.isOptional() || makeAllParametersOptional) && !param.isVariadic()) {
      emit("?");
      visitTypeDeclaration(param.getJSType(), param.isVariadic(), true);
    } else {
      visitTypeDeclaration(param.getJSType(), param.isVariadic(), false);
    }
    if (parameters.hasNext()) {
      emit(", ");
    }
  }
  emit(")");
}
 

private boolean shouldConvertToConstructor(Symbol s) {
  Node n = s.getNode();
  return n != null && (n.isClass() || (n.getJSType() != null && n.getJSType().isConstructor()));
}
 

public static boolean isUnnamedClass(Node n) {
  return n != null && n.isClass() && n.getFirstChild() != null && n.getFirstChild().isEmpty();
}