Java CompilerEnvirons.setRecoverFromErrors方法代码示例

import org.mozilla.javascript.CompilerEnvirons; //导入方法依赖的package包/类
/**
 * Compiles Text and resolves the type.
 * e.g 
 * "Hello World".length; //resolve as a Number
 * 
 * @param text to compile and resolve  
 */
@Override
public JavaScriptType compileText(String text) throws IOException {
	CompilerEnvirons env = JavaScriptParser.createCompilerEnvironment(new JavaScriptParser.JSErrorReporter(), provider.getLanguageSupport());
	
	String parseText = JavaScriptHelper.removeLastDotFromText(text);
	
	int charIndex = JavaScriptHelper.findIndexOfFirstOpeningBracket(parseText);
	env.setRecoverFromErrors(true);
	Parser parser = new Parser(env);
	StringReader r = new StringReader(parseText);
	AstRoot root = parser.parse(r, null, 0);
	CompilerNodeVisitor visitor = new CompilerNodeVisitor(charIndex == 0);
	root.visitAll(visitor);
	return lastJavaScriptType;
}
 

import org.mozilla.javascript.CompilerEnvirons; //导入方法依赖的package包/类
/**
 * Resolve node type to TypeDeclaration. Called instead of #compileText(String text) when document is already parsed
 * @param node AstNode to resolve
 * @return TypeDeclaration for node or null if not found.
 */
@Override
public TypeDeclaration resolveParamNode(String text) throws IOException {
	
	if(text != null) {
		CompilerEnvirons env = JavaScriptParser.createCompilerEnvironment(new JavaScriptParser.JSErrorReporter(), provider.getLanguageSupport());
		
		
		int charIndex = JavaScriptHelper.findIndexOfFirstOpeningBracket(text);
		env.setRecoverFromErrors(true);
		Parser parser = new Parser(env);
		StringReader r = new StringReader(text);
		AstRoot root = parser.parse(r, null, 0);
		CompilerNodeVisitor visitor = new CompilerNodeVisitor(charIndex == 0);
		root.visitAll(visitor);
	}
	
	return lastJavaScriptType != null ? lastJavaScriptType.getType()
			: provider.getTypesFactory().getDefaultTypeDeclaration();
}
 

import org.mozilla.javascript.CompilerEnvirons; //导入方法依赖的package包/类
/**
 * Creates options for Rhino based off of the user's preferences.
 *
 * @param errorHandler The container for errors found while parsing.
 * @return The properties for the JS compiler to use.
 */
public static CompilerEnvirons createCompilerEnvironment(ErrorReporter
		errorHandler, JavaScriptLanguageSupport langSupport) {
	CompilerEnvirons env = new CompilerEnvirons();
	env.setErrorReporter(errorHandler);
	env.setIdeMode(true);
	env.setRecordingComments(true);
	env.setRecordingLocalJsDocComments(true);
	env.setRecoverFromErrors(true);
	if(langSupport != null) {
		env.setXmlAvailable(langSupport.isXmlAvailable());
		env.setStrictMode(langSupport.isStrictMode());
		int version = langSupport.getLanguageVersion();
		if (version > 0) {
			Logger.log("[JavaScriptParser]: JS language version set to: " + version);
			env.setLanguageVersion(version);
		}
	}
	return env;
}
 

import org.mozilla.javascript.CompilerEnvirons; //导入方法依赖的package包/类
private String transform(String text) throws IOException {
    sb.setLength(0);
    CompilerEnvirons env = new CompilerEnvirons();
    env.setRecoverFromErrors(true);
    env.setLanguageVersion(Context.VERSION_1_8);
    JSParser factory = new JSParser(env);
    factory.enterFunction();
    AstRoot rootNode = factory.parse(new StringReader(text), null, 0);
    factory.exitFunction();
    writer.hoist(rootNode);
    writer.print(rootNode);
    return sb.toString();
}
 

import org.mozilla.javascript.CompilerEnvirons; //导入方法依赖的package包/类
private void processJSBody(Diagnostics diagnostics, MethodReader methodToProcess) {
    CallLocation location = new CallLocation(methodToProcess.getReference());
    boolean isStatic = methodToProcess.hasModifier(ElementModifier.STATIC);

    // validate parameter names
    AnnotationReader bodyAnnot = methodToProcess.getAnnotations().get(JSBody.class.getName());
    AnnotationValue paramsValue = bodyAnnot.getValue("params");
    int jsParamCount = paramsValue != null ? paramsValue.getList().size() : 0;
    if (methodToProcess.parameterCount() != jsParamCount) {
        diagnostics.error(location, "JSBody method {{m0}} declares " + methodToProcess.parameterCount()
                + " parameters, but annotation specifies " + jsParamCount, methodToProcess.getReference());
        return;
    }

    // generate parameter types for original method and validate
    int paramCount = methodToProcess.parameterCount();
    if (!isStatic) {
        ++paramCount;
    }
    if (!isStatic) {
        ValueType paramType = ValueType.object(methodToProcess.getOwnerName());
        if (!typeHelper.isSupportedType(paramType)) {
            diagnostics.error(location, "Non-static JSBody method {{m0}} is owned by non-JS class {{c1}}",
                    methodToProcess.getReference(), methodToProcess.getOwnerName());
        }
    }
    if (methodToProcess.getResultType() != ValueType.VOID
            && !typeHelper.isSupportedType(methodToProcess.getResultType())) {
        diagnostics.error(location, "JSBody method {{m0}} returns unsupported type {{t1}}",
                methodToProcess.getReference(), methodToProcess.getResultType());
    }

    // generate parameter types for proxy method
    ValueType[] proxyParamTypes = new ValueType[paramCount + 1];
    for (int i = 0; i < paramCount; ++i) {
        proxyParamTypes[i] = ValueType.parse(JSObject.class);
    }
    proxyParamTypes[paramCount] = methodToProcess.getResultType() == ValueType.VOID
            ? ValueType.VOID
            : ValueType.parse(JSObject.class);

    // create proxy method
    MethodReference proxyMethod = new MethodReference(methodToProcess.getOwnerName(),
            methodToProcess.getName() + "$js_body$_" + methodIndexGenerator++, proxyParamTypes);
    String script = bodyAnnot.getValue("script").getString();
    String[] parameterNames = paramsValue != null ? paramsValue.getList().stream()
            .map(AnnotationValue::getString)
            .toArray(String[]::new) : new String[0];

    // Parse JS script
    TeaVMErrorReporter errorReporter = new TeaVMErrorReporter(diagnostics,
            new CallLocation(methodToProcess.getReference()));
    CompilerEnvirons env = new CompilerEnvirons();
    env.setRecoverFromErrors(true);
    env.setLanguageVersion(Context.VERSION_1_8);
    env.setIdeMode(true);
    JSParser parser = new JSParser(env, errorReporter);
    AstRoot rootNode;
    try {
        rootNode = parser.parse(new StringReader("function(){" + script + "}"), null, 0);
    } catch (IOException e) {
        throw new RuntimeException("IO Error occurred", e);
    }
    AstNode body = ((FunctionNode) rootNode.getFirstChild()).getBody();

    repository.methodMap.put(methodToProcess.getReference(), proxyMethod);
    if (errorReporter.hasErrors()) {
        repository.emitters.put(proxyMethod, new JSBodyBloatedEmitter(isStatic, proxyMethod,
                script, parameterNames));
    } else {
        AstNode expr = JSBodyInlineUtil.isSuitableForInlining(methodToProcess.getReference(),
                parameterNames, body);
        if (expr != null) {
            repository.inlineMethods.add(methodToProcess.getReference());
        } else {
            expr = body;
        }
        javaInvocationProcessor.process(location, expr);
        repository.emitters.put(proxyMethod, new JSBodyAstEmitter(isStatic, expr, parameterNames));
    }
}