Java Node.setIsSyntheticBlock方法代码示例

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
public void testTypeCheckStandaloneAST() throws Exception {
  Node n = compiler.parseTestCode("function Foo() { }");
  typeCheck(n);
  TypedScopeCreator scopeCreator = new TypedScopeCreator(compiler);
  Scope topScope = scopeCreator.createScope(n, null);

  Node second = compiler.parseTestCode("new Foo");

  Node externs = new Node(Token.BLOCK);
  Node externAndJsRoot = new Node(Token.BLOCK, externs, second);
  externAndJsRoot.setIsSyntheticBlock(true);

  new TypeCheck(
      compiler,
      new SemanticReverseAbstractInterpreter(
          compiler.getCodingConvention(), registry),
      registry, topScope, scopeCreator, CheckLevel.WARNING, CheckLevel.OFF)
      .process(null, second);

  assertEquals(1, compiler.getWarningCount());
  assertEquals("cannot instantiate non-constructor",
      compiler.getWarnings()[0].description);
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
static Node parse(String js, boolean checkTypes) {
  Compiler compiler = new Compiler();
  Node n = compiler.parseTestCode(js);

  if (checkTypes) {
    CompilerPass typeResolver = new DefaultPassConfig(null)
        .resolveTypes.create(compiler);
    Node externs = new Node(Token.SCRIPT);
    Node externAndJsRoot = new Node(Token.BLOCK, externs, n);
    externAndJsRoot.setIsSyntheticBlock(true);
    typeResolver.process(externs, n);
  }

  assertEquals("Errors for: " + js, 0, compiler.getErrorCount());
  return n;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
/**
 * Parses the JavaScript text given by a reader.
 *
 * @param sourceName The filename.
 * @param sourceString Source code from the file.
 * @param errorReporter An error.
 * @param logger A logger.
 * @return The AST of the given text.
 * @throws IOException
 */
public static Node parse(String sourceName,
                         String sourceString,
                         Config config,
                         ErrorReporter errorReporter,
                         Logger logger) throws IOException {
  Context cx = Context.enter();
  cx.setErrorReporter(errorReporter);
  cx.setLanguageVersion(Context.VERSION_1_5);
  CompilerEnvirons compilerEnv = new CompilerEnvirons();
  compilerEnv.initFromContext(cx);
  compilerEnv.setRecordingComments(true);
  compilerEnv.setRecordingLocalJsDocComments(true);
  compilerEnv.setWarnTrailingComma(true);
  if (config.isIdeMode) {
    compilerEnv.setReservedKeywordAsIdentifier(true);
    compilerEnv.setAllowMemberExprAsFunctionName(true);
  }

  Parser p = new Parser(compilerEnv, errorReporter);
  AstRoot astRoot = null;
  try {
    astRoot = p.parse(sourceString, sourceName, 1);
  } catch (EvaluatorException e) {
    logger.info("Error parsing " + sourceName + ": " + e.getMessage());
  } finally {
    Context.exit();
  }
  Node root = null;
  if (astRoot != null) {
    root = IRFactory.transformTree(
        astRoot, sourceString, config, errorReporter);
    root.setIsSyntheticBlock(true);
  }
  return root;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
/**
 * Type checks a NAME node and retrieve its type.
 */
private JSType testNameNode(String name) {
  Node node = Node.newString(Token.NAME, name);
  Node parent = new Node(Token.SCRIPT, node);

  Node externs = new Node(Token.BLOCK);
  Node externAndJsRoot = new Node(Token.BLOCK, externs, parent);
  externAndJsRoot.setIsSyntheticBlock(true);

  makeTypeCheck().processForTesting(null, parent);
  return node.getJSType();
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
private double getTypedPercent(String js) throws Exception {
  Node n = compiler.parseTestCode(js);

  Node externs = new Node(Token.BLOCK);
  Node externAndJsRoot = new Node(Token.BLOCK, externs, n);
  externAndJsRoot.setIsSyntheticBlock(true);

  TypeCheck t = makeTypeCheck();
  t.processForTesting(null, n);
  return t.getTypedPercent();
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
private void testClosureTypes(String js, String description)
    throws Exception {
  Node n = compiler.parseTestCode(js);
  Node externs = new Node(Token.BLOCK);
  Node externAndJsRoot = new Node(Token.BLOCK, externs, n);
  externAndJsRoot.setIsSyntheticBlock(true);

  assertEquals("parsing error: " +
      Joiner.on(", ").join(compiler.getErrors()),
      0, compiler.getErrorCount());

  // For processing goog.addDependency for forward typedefs.
  new ProcessClosurePrimitives(compiler, CheckLevel.ERROR, true)
      .process(null, n);

  CodingConvention convention = compiler.getCodingConvention();
  new TypeCheck(compiler,
      new ClosureReverseAbstractInterpreter(
          convention, registry).append(
              new SemanticReverseAbstractInterpreter(
                  convention, registry))
          .getFirst(),
      registry)
      .processForTesting(null, n);

  assertEquals(0, compiler.getErrorCount());

  if (description == null) {
    assertEquals(
        "unexpected warning(s) : " +
        Joiner.on(", ").join(compiler.getWarnings()),
        0, compiler.getWarningCount());
  } else {
    assertEquals(1, compiler.getWarningCount());
    assertEquals(description, compiler.getWarnings()[0].description);
  }
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
private TypeCheckResult parseAndTypeCheckWithScope(String externs,
                                                     String js) {
  Node externsNode = compiler.parseTestCode(externs);
  Node n = compiler.parseTestCode(js);
  Node externAndJsRoot = new Node(Token.BLOCK, externsNode, n);
  externAndJsRoot.setIsSyntheticBlock(true);

  assertEquals("parsing error: " +
      Joiner.on(", ").join(compiler.getErrors()),
      0, compiler.getErrorCount());

  Scope s = makeTypeCheck().processForTesting(externsNode, n);
  return new TypeCheckResult(n, s);
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
private Node typeCheck(Node n) {
  Node externsNode = new Node(Token.BLOCK);
  Node externAndJsRoot = new Node(Token.BLOCK, externsNode, n);
  externAndJsRoot.setIsSyntheticBlock(true);

  makeTypeCheck().processForTesting(null, n);
  return n;
}