Java CompilationFailedException类代码示例

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
@Override
public void call(SourceUnit source) throws CompilationFailedException {
    BlockStatement statementBlock = source.getAST().getStatementBlock();
    List<Statement> statements = statementBlock.getStatements();
    for (Statement statement : statements) {
        if (!AstUtils.mayHaveAnEffect(statement)) {
            continue;
        }
        ScriptBlock scriptBlock = AstUtils.detectScriptBlock(statement);
        if (scriptBlock != null && scriptBlock.getName().equals(ModelBlockTransformer.MODEL)) {
            continue;
        }
        imperativeStatementDetected = true;
        break;
    }
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
@Override
public void call(final SourceUnit source) throws CompilationFailedException {
    // currently we only look in script code; could extend this to build script classes
    AstUtils.visitScriptCode(source, new ClassCodeVisitorSupport() {
        @Override
        protected SourceUnit getSourceUnit() {
            return source;
        }

        @Override
        protected void visitStatement(Statement statement) {
            if (statement.getStatementLabel() != null) {
                String message = String.format("Statement labels may not be used in build scripts.%nIn case you tried to configure a property named '%s', replace ':' with '=' or ' ', otherwise it will not have the desired effect.",
                        statement.getStatementLabel());
                addError(message, statement);
            }
        }
    });
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
/**
 * 重载脚本
 * 
 * @param scriptId
 * @throws IOException
 * @throws CompilationFailedException
 * @throws IllegalAccessException
 * @throws InstantiationException
 * @throws ScriptException
 */
public AbstractScriptLoader<KEY> reloadScript(KEY scriptId) throws CompilationFailedException, IOException,
		InstantiationException, IllegalAccessException, ScriptException {
	File file = scriptPath.get(scriptId);
	Objects.requireNonNull(file, "script id:" + scriptId + " does not exist!");
	try (GroovyClassLoader loader = new GroovyClassLoader(ClassLoader.getSystemClassLoader())) {
		Class<?> parseClass = loader.parseClass(file);
		Object newInstance = parseClass.newInstance();
		if (!(newInstance instanceof IScript)) {
			throw new ScriptException("script file must implement IScript:" + file.getName());
		}
		@SuppressWarnings("unchecked")
		IScript<KEY> newScript = (IScript<KEY>) newInstance;
		scriptMap.put(scriptId, newScript);
		log.info("reload script success:" + file.getName());
	}
	return this;
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
private void initGroovyTransformer(String code, List<String> extraPackage) {
    GroovyClassLoader loader = new GroovyClassLoader(GroovyTransformer.class.getClassLoader());
    String groovyRule = getGroovyRule(code, extraPackage);

    Class groovyClass;
    try {
        groovyClass = loader.parseClass(groovyRule);
    } catch (CompilationFailedException cfe) {
        throw DataXException.asDataXException(TransformerErrorCode.TRANSFORMER_GROOVY_INIT_EXCEPTION, cfe);
    }

    try {
        Object t = groovyClass.newInstance();
        if (!(t instanceof Transformer)) {
            throw DataXException.asDataXException(TransformerErrorCode.TRANSFORMER_GROOVY_INIT_EXCEPTION, "datax bug! contact askdatax");
        }
        this.groovyTransformer = (Transformer) t;
    } catch (Throwable ex) {
        throw DataXException.asDataXException(TransformerErrorCode.TRANSFORMER_GROOVY_INIT_EXCEPTION, ex);
    }
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
/**
 * Instantiates a new groovy script.
 * 
 * @param script
 *            the script
 * @param timeout
 * @throws IOException
 * @throws CompilationFailedException
 * @throws IllegalAccessException
 * @throws InstantiationException
 * @throws ClassNotFoundException
 */
public GroovyScript(final String script, final String id,
		final WrappedProcess process, final String[] args,
		final int timeout, final InternalLogger logger, String encoding,
		boolean reload, int maxConcInvocations)
		throws CompilationFailedException, IOException,
		InstantiationException, IllegalAccessException,
		ClassNotFoundException
{
	super(script, id, process, args, timeout, maxConcInvocations);
	_reload = reload;
	_encoding = encoding;

	// let's call some method on an instance
	_script = getScriptInstance(script, encoding);
	binding = (Binding) _script.invokeMethod("getBinding", null);
	binding.setVariable("args", args);
	binding.setVariable("callCount", 0);
	binding.setVariable("context", context);
	if (process != null && logger == null)
		_logger = process.getInternalWrapperLogger();
	else
		_logger = logger;
	binding.setVariable("logger", _logger);
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
private static Template getTemplate(TemplateEngine engine, String name)
		throws CompilationFailedException, ClassNotFoundException, IOException {

	File file = new File("templates", name);
	if (file.exists()) {
		return engine.createTemplate(file);
	}

	ClassLoader classLoader = GroovyTemplate.class.getClassLoader();
	URL resource = classLoader.getResource("templates/" + name);
	if (resource != null) {
		return engine.createTemplate(resource);
	}

	return engine.createTemplate(name);
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
@Override
public List<File> resolve(List<String> artifactIdentifiers)
		throws CompilationFailedException, IOException {
	GroovyCompiler groovyCompiler = new GroovyCompiler(this.configuration);
	List<File> artifactFiles = new ArrayList<File>();
	if (!artifactIdentifiers.isEmpty()) {
		List<URL> initialUrls = getClassPathUrls(groovyCompiler);
		groovyCompiler.compile(createSources(artifactIdentifiers));
		List<URL> artifactUrls = getClassPathUrls(groovyCompiler);
		artifactUrls.removeAll(initialUrls);
		for (URL artifactUrl : artifactUrls) {
			artifactFiles.add(toFile(artifactUrl));
		}
	}
	return artifactFiles;
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
@Override
public void call(SourceUnit source, GeneratorContext context, ClassNode classNode)
		throws CompilationFailedException {

	ImportCustomizer importCustomizer = new SmartImportCustomizer(source, context,
			classNode);
	ClassNode mainClassNode = MainClass.get(source.getAST().getClasses());

	// Additional auto configuration
	for (CompilerAutoConfiguration autoConfiguration : GroovyCompiler.this.compilerAutoConfigurations) {
		if (autoConfiguration.matches(classNode)) {
			if (GroovyCompiler.this.configuration.isGuessImports()) {
				autoConfiguration.applyImports(importCustomizer);
				importCustomizer.call(source, context, classNode);
			}
			if (classNode.equals(mainClassNode)) {
				autoConfiguration.applyToMainClass(GroovyCompiler.this.loader,
						GroovyCompiler.this.configuration, context, source,
						classNode);
			}
			autoConfiguration.apply(GroovyCompiler.this.loader,
					GroovyCompiler.this.configuration, context, source,
					classNode);
		}
	}
	importCustomizer.call(source, context, classNode);
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
private CompilationFailedException createParsingFailedException(Throwable t) {
    if (t instanceof SyntaxException) {
        this.collectSyntaxError((SyntaxException) t);
    } else if (t instanceof GroovySyntaxError) {
        GroovySyntaxError groovySyntaxError = (GroovySyntaxError) t;

        this.collectSyntaxError(
                new SyntaxException(
                        groovySyntaxError.getMessage(),
                        groovySyntaxError,
                        groovySyntaxError.getLine(),
                        groovySyntaxError.getColumn()));
    } else if (t instanceof Exception) {
        this.collectException((Exception) t);
    }

    return new CompilationFailedException(
            CompilePhase.PARSING.getPhaseNumber(),
            this.sourceUnit,
            t);
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
@Override
public void call(final SourceUnit source, final GeneratorContext context, final ClassNode classNode) throws CompilationFailedException {
    final ModuleNode ast = source.getAST();
    for (Import anImport : imports) {
        switch (anImport.type) {
            case regular:
                ast.addImport(anImport.alias, anImport.classNode);
                break;
            case staticImport:
                ast.addStaticImport(anImport.classNode, anImport.field, anImport.alias);
                break;
            case staticStar:
                ast.addStaticStarImport(anImport.alias, anImport.classNode);
                break;
            case star:
                ast.addStarImport(anImport.star);
                break;
        }
    }
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
private void registerASTTransformations(final ClassNode helper) {
    ASTTransformationCollectorCodeVisitor collector = new ASTTransformationCollectorCodeVisitor(
            unit, compilationUnit.getTransformLoader()
    );
    collector.visitClass(helper);
    // Perform an additional phase which has to be done *after* type checking
    compilationUnit.addPhaseOperation(new CompilationUnit.PrimaryClassNodeOperation() {
        @Override
        public void call(final SourceUnit source, final GeneratorContext context, final ClassNode classNode) throws CompilationFailedException {
            if (classNode==helper) {
                PostTypeCheckingExpressionReplacer replacer = new PostTypeCheckingExpressionReplacer(source);
                replacer.visitClass(helper);
            }
        }
    }, CompilePhase.INSTRUCTION_SELECTION.getPhaseNumber());
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
public void gotoPhase(int phase) throws CompilationFailedException {
    super.gotoPhase(phase);
    // compile Java and clean up
    if (phase == Phases.SEMANTIC_ANALYSIS && !javaSources.isEmpty()) {
        for (ModuleNode module : getAST().getModules()) {
            module.setImportsResolved(false);
        }
        try {
            JavaCompiler compiler = compilerFactory.createCompiler(getConfiguration());
            compiler.compile(javaSources, this);
        } finally {
            if (!keepStubs) stubGenerator.clean();
            javaSources.clear();
        }
    }
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
@Override
public void call(SourceUnit source) throws CompilationFailedException {
    List<Statement> statements = source.getAST().getStatementBlock().getStatements();
    for (Statement statement : statements) {
        ScriptBlock scriptBlock = AstUtils.detectScriptBlock(statement, SCRIPT_BLOCK_NAMES);
        if (scriptBlock == null) {
            // Look for model(«») (i.e. call to model with anything other than non literal closure)
            MethodCallExpression methodCall = AstUtils.extractBareMethodCall(statement);
            if (methodCall == null) {
                continue;
            }

            String methodName = AstUtils.extractConstantMethodName(methodCall);
            if (methodName == null) {
                continue;
            }

            if (methodName.equals(MODEL)) {
                source.getErrorCollector().addError(
                        new SyntaxException(NON_LITERAL_CLOSURE_TO_TOP_LEVEL_MODEL_MESSAGE, statement.getLineNumber(), statement.getColumnNumber()),
                        source
                );
            }
        } else {
            RuleVisitor ruleVisitor = new RuleVisitor(source, scriptSourceDescription, location);
            RulesVisitor rulesVisitor = new RulesVisitor(source, ruleVisitor);
            scriptBlock.getClosureExpression().getCode().visit(rulesVisitor);
        }
    }
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
@Override
public void call(SourceUnit source) throws CompilationFailedException {
    ListIterator<Statement> iterator = source.getAST().getStatementBlock().getStatements().listIterator();
    while (iterator.hasNext()) {
        if (spec.isSatisfiedBy(iterator.next())) {
            iterator.remove();
        }
    }
}
 

import org.codehaus.groovy.control.CompilationFailedException; //导入依赖的package包/类
@Override
public void call(SourceUnit source) throws CompilationFailedException {
    ClassNode scriptClass = AstUtils.getScriptClass(source);
    if (scriptClass == null) {
        return;
    }
    for (MethodNode methodNode : scriptClass.getMethods()) {
        if (methodNode.getName().equals("main")) {
            AstUtils.removeMethod(scriptClass, methodNode);
            break;
        }
    }
}