use of org.metaborg.spoofax.core.analysis.ISpoofaxAnalyzer in project spoofax by metaborg.
the class LanguageComponentFactory method createConfig.
@Override
public ComponentCreationConfig createConfig(IComponentCreationConfigRequest configRequest) throws MetaborgException {
final ComponentFactoryRequest request = (ComponentFactoryRequest) configRequest;
final FileObject location = request.location();
if (!request.valid()) {
throw new MetaborgException(request.toString());
}
final ILanguageComponentConfig componentConfig = request.config();
logger.debug("Creating language component for {}", location);
final LanguageIdentifier identifier = componentConfig.identifier();
final Collection<LanguageContributionIdentifier> langContribs = request.config().langContribs();
if (langContribs.isEmpty()) {
langContribs.add(new LanguageContributionIdentifier(identifier, componentConfig.name()));
}
final ComponentCreationConfig config = new ComponentCreationConfig(identifier, location, langContribs, componentConfig);
final SyntaxFacet syntaxFacet;
if (componentConfig.sdfEnabled()) {
syntaxFacet = request.syntaxFacet();
if (syntaxFacet != null) {
config.addFacet(syntaxFacet);
}
} else {
syntaxFacet = null;
}
final StrategoRuntimeFacet strategoRuntimeFacet = request.strategoRuntimeFacet();
if (strategoRuntimeFacet != null) {
config.addFacet(strategoRuntimeFacet);
}
final IStrategoAppl esvTerm = request.esvTerm();
if (esvTerm != null) {
final String[] extensions = extensions(esvTerm);
if (extensions.length != 0) {
final Iterable<String> extensionsIterable = Iterables2.from(extensions);
final IdentificationFacet identificationFacet = new IdentificationFacet(new ResourceExtensionsIdentifier(extensionsIterable));
config.addFacet(identificationFacet);
final ResourceExtensionFacet resourceExtensionsFacet = new ResourceExtensionFacet(extensionsIterable);
config.addFacet(resourceExtensionsFacet);
}
if (ParseFacetFromESV.hasParser(esvTerm)) {
config.addFacet(ParseFacetFromESV.create(esvTerm));
} else if (syntaxFacet != null) {
config.addFacet(new ParseFacet("jsglr"));
}
final boolean hasContext = ContextFacetFromESV.hasContext(esvTerm);
final boolean hasAnalysis = AnalysisFacetFromESV.hasAnalysis(esvTerm);
final IContextFactory contextFactory;
final ISpoofaxAnalyzer analyzer;
final AnalysisFacet analysisFacet;
if (hasAnalysis) {
final String analysisType = AnalysisFacetFromESV.type(esvTerm);
assert analysisType != null : "Analyzer type cannot be null because hasAnalysis is true, no null check is needed.";
analyzer = analyzers.get(analysisType);
analysisFacet = AnalysisFacetFromESV.create(esvTerm);
final String contextType = hasContext ? ContextFacetFromESV.type(esvTerm) : null;
if (hasContext && contextType == null) {
contextFactory = null;
} else {
final String analysisContextType;
switch(analysisType) {
default:
case StrategoAnalyzer.name:
analysisContextType = LegacyContextFactory.name;
break;
case TaskEngineAnalyzer.name:
analysisContextType = IndexTaskContextFactory.name;
break;
case ConstraintSingleFileAnalyzer.name:
analysisContextType = SingleFileScopeGraphContextFactory.name;
break;
case ConstraintMultiFileAnalyzer.name:
analysisContextType = MultiFileScopeGraphContextFactory.name;
break;
}
if (hasContext && !analysisContextType.equals(contextType)) {
logger.warn("Ignoring explicit context type {}, because it is incompatible with analysis {}.", contextType, analysisType);
}
contextFactory = contextFactory(analysisContextType);
}
} else if (hasContext) {
final String type = ContextFacetFromESV.type(esvTerm);
contextFactory = contextFactory(type);
analyzer = null;
analysisFacet = null;
} else {
contextFactory = contextFactory(LegacyContextFactory.name);
analyzer = null;
analysisFacet = null;
}
if (contextFactory != null) {
final IContextStrategy contextStrategy = contextStrategy(ProjectContextStrategy.name);
config.addFacet(new ContextFacet(contextFactory, contextStrategy));
}
if (analyzer != null) {
config.addFacet(new AnalyzerFacet<>(analyzer));
}
if (analysisFacet != null) {
config.addFacet(analysisFacet);
}
final ActionFacet menusFacet = ActionFacetFromESV.create(esvTerm);
if (menusFacet != null) {
config.addFacet(menusFacet);
}
final StylerFacet stylerFacet = StylerFacetFromESV.create(esvTerm);
if (stylerFacet != null) {
config.addFacet(stylerFacet);
}
final ResolverFacet resolverFacet = ResolverFacetFromESV.createResolver(esvTerm);
if (resolverFacet != null) {
config.addFacet(resolverFacet);
}
final HoverFacet hoverFacet = ResolverFacetFromESV.createHover(esvTerm);
if (hoverFacet != null) {
config.addFacet(hoverFacet);
}
final OutlineFacet outlineFacet = OutlineFacetFromESV.create(esvTerm);
if (outlineFacet != null) {
config.addFacet(outlineFacet);
}
final ShellFacet shellFacet = ShellFacetFromESV.create(esvTerm);
if (shellFacet != null) {
config.addFacet(shellFacet);
}
}
return config;
}
Aggregations