private static boolean matchFramework(
ProjectCategory projectCategory, FrameworkSupportInModuleProvider framework) {
FrameworkRole[] roles = framework.getRoles();
if (roles.length == 0) return true;
List<FrameworkRole> acceptable = Arrays.asList(projectCategory.getAcceptableFrameworkRoles());
return ContainerUtil.intersects(Arrays.asList(roles), acceptable);
}
public static void markDirtyRecursively(
CompileContext context,
final CompilationRound round,
ModuleChunk chunk,
@Nullable FileFilter filter)
throws IOException {
Set<JpsModule> modules = chunk.getModules();
Set<ModuleBuildTarget> targets = chunk.getTargets();
final Set<ModuleBuildTarget> dirtyTargets = new HashSet<ModuleBuildTarget>(targets);
// now mark all modules that depend on dirty modules
final JpsJavaClasspathKind classpathKind = JpsJavaClasspathKind.compile(chunk.containsTests());
boolean found = false;
for (BuildTargetChunk targetChunk :
context.getProjectDescriptor().getBuildTargetIndex().getSortedTargetChunks(context)) {
if (!found) {
if (targetChunk.getTargets().equals(chunk.getTargets())) {
found = true;
}
} else {
for (final BuildTarget<?> target : targetChunk.getTargets()) {
if (target instanceof ModuleBuildTarget) {
final Set<JpsModule> deps =
getDependentModulesRecursively(
((ModuleBuildTarget) target).getModule(), classpathKind);
if (ContainerUtil.intersects(deps, modules)) {
for (BuildTarget<?> buildTarget : targetChunk.getTargets()) {
if (buildTarget instanceof ModuleBuildTarget) {
dirtyTargets.add((ModuleBuildTarget) buildTarget);
}
}
break;
}
}
}
}
}
removeTargetsAlreadyMarkedDirty(context, dirtyTargets);
final Timestamps timestamps = context.getProjectDescriptor().timestamps.getStorage();
for (ModuleBuildTarget target : dirtyTargets) {
markDirtyFiles(context, target, round, timestamps, true, null, filter);
}
if (JavaBuilderUtil.isCompileJavaIncrementally(context)) {
// mark as non-incremental only the module that triggered non-incremental change
for (ModuleBuildTarget target : targets) {
context.markNonIncremental(target);
}
}
}
@HasJavaSources
public void testStrutsSpringCompletionVariants() throws Throwable {
@NonNls final String strutsXml = "struts-completionvariants-spring.xml";
createStrutsFileSet(strutsXml);
createSpringFileSet(SPRING_XML);
// TODO <alias> does not appear here, see com.intellij.spring.impl.SpringModelImpl#myOwnBeans
final List<String> variants = myFixture.getCompletionVariants(strutsXml);
assert variants != null;
List<String> strings =
Arrays.asList("MyClass", "bean1", "bean2", "springInterceptor", "springResultType");
for (String s : strings) {
Assert.assertTrue(variants.indexOf(s) != -1);
}
Assert.assertFalse(ContainerUtil.intersects(variants, Arrays.asList("abstractBean")));
}
private boolean uniteClasses(int c1Index, int c2Index) {
EqClass c1 = myEqClasses.get(c1Index);
EqClass c2 = myEqClasses.get(c2Index);
Set<DfaVariableValue> vars = ContainerUtil.newTroveSet();
Set<DfaVariableValue> negatedVars = ContainerUtil.newTroveSet();
int[] cs = new int[c1.size() + c2.size()];
c1.set(0, cs, 0, c1.size());
c2.set(0, cs, c1.size(), c2.size());
int nConst = 0;
for (int c : cs) {
DfaValue dfaValue = unwrap(myFactory.getValue(c));
if (dfaValue instanceof DfaConstValue) nConst++;
if (dfaValue instanceof DfaVariableValue) {
DfaVariableValue variableValue = (DfaVariableValue) dfaValue;
if (variableValue.isNegated()) {
negatedVars.add(variableValue.createNegated());
} else {
vars.add(variableValue);
}
}
if (nConst > 1) return false;
}
if (ContainerUtil.intersects(vars, negatedVars)) return false;
TLongArrayList c2Pairs = new TLongArrayList();
long[] distincts = myDistinctClasses.toArray();
for (long distinct : distincts) {
int pc1 = low(distinct);
int pc2 = high(distinct);
boolean addedToC1 = false;
if (pc1 == c1Index || pc2 == c1Index) {
addedToC1 = true;
}
if (pc1 == c2Index || pc2 == c2Index) {
if (addedToC1) return false;
c2Pairs.add(distinct);
}
}
EqClass newClass = new EqClass(c1);
myEqClasses.set(c1Index, newClass);
for (int i = 0; i < c2.size(); i++) {
int c = c2.get(i);
newClass.add(c);
removeFromMap(c, c2Index);
addToMap(c, c1Index);
}
for (int i = 0; i < c2Pairs.size(); i++) {
long c = c2Pairs.get(i);
myDistinctClasses.remove(c);
myDistinctClasses.add(createPair(c1Index, low(c) == c2Index ? high(c) : low(c)));
}
myEqClasses.set(c2Index, null);
return true;
}