From ef0b2baa6a5d1fbbd7d2f6d070a0aa21924e4213 Mon Sep 17 00:00:00 2001 From: nik Date: Tue, 10 Aug 2010 15:26:55 +0400 Subject: [PATCH] notnullification (IDEA-57345) --- .../compiler/impl/GenericCompilerRunner.java | 12 ++--- .../impl/generic/GenericCompilerCache.java | 5 +- ...te.java => GenericCompilerCacheState.java} | 17 ++++--- .../generic/GenericCompilerInstance.java | 4 +- .../GenericCompilerProcessingItem.java | 49 +++++++++++++++++++ .../generic/SingleTargetCompilerInstance.java | 2 +- .../compiler/ArtifactsCompilerInstance.java | 27 +++++----- 7 files changed, 86 insertions(+), 30 deletions(-) rename java/compiler/impl/src/com/intellij/openapi/compiler/generic/{GenericCompilerItemState.java => GenericCompilerCacheState.java} (73%) create mode 100644 java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerProcessingItem.java diff --git a/java/compiler/impl/src/com/intellij/compiler/impl/GenericCompilerRunner.java b/java/compiler/impl/src/com/intellij/compiler/impl/GenericCompilerRunner.java index d684757dc81c..d5ff51d84c48 100644 --- a/java/compiler/impl/src/com/intellij/compiler/impl/GenericCompilerRunner.java +++ b/java/compiler/impl/src/com/intellij/compiler/impl/GenericCompilerRunner.java @@ -117,10 +117,10 @@ public class GenericCompilerRunner { @Override public void run() throws IOException { cache.processSources(id, new CommonProcessors.CollectProcessor(keys)); - List> obsoleteSources = new ArrayList>(); + List> obsoleteSources = new ArrayList>(); for (Key key : keys) { final GenericCompilerCache.PersistentStateData state = cache.getState(id, key); - obsoleteSources.add(new GenericCompilerItemState(key, state.mySourceState, state.myOutputState)); + obsoleteSources.add(new GenericCompilerCacheState(key, state.mySourceState, state.myOutputState)); } instance.processObsoleteTarget(target, obsoleteSources); } @@ -164,7 +164,7 @@ public class GenericCompilerRunner { final List items = instance.getItems(target); checkForErrorsOrCanceled(); - final List> toProcess = new ArrayList>(); + final List> toProcess = new ArrayList>(); final THashSet keySet = new THashSet(new SourceItemHashingStrategy(compiler)); final Ref exception = Ref.create(null); DumbService.getInstance(myProject).waitForSmartMode(); @@ -182,7 +182,7 @@ public class GenericCompilerRunner { if (myForceCompile || sourceState == null || !item.isSourceUpToDate(sourceState) || outputState == null || !item.isOutputUpToDate(outputState)) { sourceStates.put(item, item.computeSourceState()); - toProcess.add(new GenericCompilerItemState(item, sourceState, outputState)); + toProcess.add(new GenericCompilerProcessingItem(item, sourceState, outputState)); } } } @@ -218,10 +218,10 @@ public class GenericCompilerRunner { throw new CompileDriver.ExitException(CompileDriver.ExitStatus.CANCELLED); } - List> obsoleteItems = new ArrayList>(); + List> obsoleteItems = new ArrayList>(); for (Key key : toRemove) { final GenericCompilerCache.PersistentStateData data = cache.getState(targetId, key); - obsoleteItems.add(new GenericCompilerItemState(key, data.mySourceState, data.myOutputState)); + obsoleteItems.add(new GenericCompilerCacheState(key, data.mySourceState, data.myOutputState)); } final List processedItems = new ArrayList(); diff --git a/java/compiler/impl/src/com/intellij/compiler/impl/generic/GenericCompilerCache.java b/java/compiler/impl/src/com/intellij/compiler/impl/generic/GenericCompilerCache.java index 10152880e5f1..9217bde65a71 100644 --- a/java/compiler/impl/src/com/intellij/compiler/impl/generic/GenericCompilerCache.java +++ b/java/compiler/impl/src/com/intellij/compiler/impl/generic/GenericCompilerCache.java @@ -21,6 +21,7 @@ import com.intellij.util.Processor; import com.intellij.util.io.DataExternalizer; import com.intellij.util.io.KeyDescriptor; import com.intellij.util.io.PersistentHashMap; +import org.jetbrains.annotations.NotNull; import java.io.DataInput; import java.io.DataOutput; @@ -87,7 +88,7 @@ public class GenericCompilerCache { }); } - public void putState(int targetId, Key key, SourceState sourceState, OutputState outputState) throws IOException { + public void putState(int targetId, @NotNull Key key, @NotNull SourceState sourceState, @NotNull OutputState outputState) throws IOException { myPersistentMap.put(getKeyAndTargetData(key, targetId), new PersistentStateData(sourceState, outputState)); } @@ -106,7 +107,7 @@ public class GenericCompilerCache { public final SourceState mySourceState; public final OutputState myOutputState; - private PersistentStateData(SourceState sourceState, OutputState outputState) { + private PersistentStateData(@NotNull SourceState sourceState, @NotNull OutputState outputState) { mySourceState = sourceState; myOutputState = outputState; } diff --git a/java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerItemState.java b/java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerCacheState.java similarity index 73% rename from java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerItemState.java rename to java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerCacheState.java index 6166117fb79d..bfc44686893b 100644 --- a/java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerItemState.java +++ b/java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerCacheState.java @@ -15,28 +15,33 @@ */ package com.intellij.openapi.compiler.generic; +import org.jetbrains.annotations.NotNull; + /** * @author nik */ -public class GenericCompilerItemState { - private final Item myItem; +public class GenericCompilerCacheState { + private final Key myKey; private final SourceState mySourceState; private final OutputState myOutputState; - public GenericCompilerItemState(Item item, SourceState sourceState, OutputState outputState) { - myItem = item; + public GenericCompilerCacheState(@NotNull Key key, @NotNull SourceState sourceState, @NotNull OutputState outputState) { + myKey = key; mySourceState = sourceState; myOutputState = outputState; } - public Item getItem() { - return myItem; + @NotNull + public Key getKey() { + return myKey; } + @NotNull public SourceState getSourceState() { return mySourceState; } + @NotNull public OutputState getOutputState() { return myOutputState; } diff --git a/java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerInstance.java b/java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerInstance.java index c13da612ac8e..c00f57341309 100644 --- a/java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerInstance.java +++ b/java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerInstance.java @@ -42,13 +42,13 @@ public abstract class GenericCompilerInstance getSelectedTargets(); - public abstract void processObsoleteTarget(@NotNull String targetId, @NotNull List> obsoleteItems); + public abstract void processObsoleteTarget(@NotNull String targetId, @NotNull List> obsoleteItems); @NotNull public abstract List getItems(@NotNull T target); - public abstract void processItems(@NotNull T target, @NotNull List> changedItems, @NotNull List> obsoleteItems, + public abstract void processItems(@NotNull T target, @NotNull List> changedItems, @NotNull List> obsoleteItems, @NotNull OutputConsumer consumer); public interface OutputConsumer> { diff --git a/java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerProcessingItem.java b/java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerProcessingItem.java new file mode 100644 index 000000000000..e62a5b3d58cf --- /dev/null +++ b/java/compiler/impl/src/com/intellij/openapi/compiler/generic/GenericCompilerProcessingItem.java @@ -0,0 +1,49 @@ +/* + * Copyright 2000-2010 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.openapi.compiler.generic; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * @author nik + */ +public class GenericCompilerProcessingItem, SourceState, OutputState> { + private final Item myItem; + private final SourceState myCachedSourceState; + private final OutputState myCachedOutputState; + + public GenericCompilerProcessingItem(@NotNull Item item, @Nullable SourceState cachedSourceState, @Nullable OutputState cachedOutputState) { + myItem = item; + myCachedSourceState = cachedSourceState; + myCachedOutputState = cachedOutputState; + } + + @NotNull + public Item getItem() { + return myItem; + } + + @Nullable + public SourceState getCachedSourceState() { + return myCachedSourceState; + } + + @Nullable + public OutputState getCachedOutputState() { + return myCachedOutputState; + } +} diff --git a/java/compiler/impl/src/com/intellij/openapi/compiler/generic/SingleTargetCompilerInstance.java b/java/compiler/impl/src/com/intellij/openapi/compiler/generic/SingleTargetCompilerInstance.java index 247291157498..f2e4dd3ca71e 100644 --- a/java/compiler/impl/src/com/intellij/openapi/compiler/generic/SingleTargetCompilerInstance.java +++ b/java/compiler/impl/src/com/intellij/openapi/compiler/generic/SingleTargetCompilerInstance.java @@ -43,6 +43,6 @@ public abstract class SingleTargetCompilerInstance> obsoleteItems) { + public void processObsoleteTarget(@NotNull String targetId, @NotNull List> obsoleteItems) { } } diff --git a/java/compiler/impl/src/com/intellij/packaging/impl/compiler/ArtifactsCompilerInstance.java b/java/compiler/impl/src/com/intellij/packaging/impl/compiler/ArtifactsCompilerInstance.java index 777e0ead9582..acf03b898c3f 100644 --- a/java/compiler/impl/src/com/intellij/packaging/impl/compiler/ArtifactsCompilerInstance.java +++ b/java/compiler/impl/src/com/intellij/packaging/impl/compiler/ArtifactsCompilerInstance.java @@ -17,8 +17,9 @@ package com.intellij.packaging.impl.compiler; import com.intellij.compiler.CompilerManagerImpl; import com.intellij.compiler.impl.CompilerUtil; +import com.intellij.openapi.compiler.generic.GenericCompilerCacheState; import com.intellij.openapi.compiler.generic.GenericCompilerInstance; -import com.intellij.openapi.compiler.generic.GenericCompilerItemState; +import com.intellij.openapi.compiler.generic.GenericCompilerProcessingItem; import com.intellij.openapi.compiler.generic.VirtualFilePersistentState; import com.intellij.compiler.impl.packagingCompiler.*; import com.intellij.openapi.application.ApplicationManager; @@ -120,8 +121,8 @@ public class ArtifactsCompilerInstance extends GenericCompilerInstance> obsoleteItems) { - deleteFiles(obsoleteItems, Collections.>emptyList()); + @NotNull List> obsoleteItems) { + deleteFiles(obsoleteItems, Collections.>emptyList()); } @NotNull @@ -163,7 +164,7 @@ public class ArtifactsCompilerInstance extends GenericCompilerInstance> changedItems, + private boolean doBuild(final List> changedItems, final Set processedItems, final @NotNull Set writtenPaths, final Set deletedJars) { final boolean testMode = ApplicationManager.getApplication().isUnitTestMode(); @@ -182,7 +183,7 @@ public class ArtifactsCompilerInstance extends GenericCompilerInstance item : changedItems) { + for (final GenericCompilerProcessingItem item : changedItems) { final ArtifactCompilerCompileItem sourceItem = item.getItem(); myContext.getProgressIndicator().checkCanceled(); @@ -308,8 +309,8 @@ public class ArtifactsCompilerInstance extends GenericCompilerInstance> changedItems, - @NotNull List> obsoleteItems, + @NotNull final List> changedItems, + @NotNull List> obsoleteItems, @NotNull OutputConsumer consumer) { final THashSet deletedJars = deleteFiles(obsoleteItems, changedItems); @@ -337,8 +338,8 @@ public class ArtifactsCompilerInstance extends GenericCompilerInstance deleteFiles(List> obsoleteItems, - List> changedItems) { + private THashSet deleteFiles(List> obsoleteItems, + List> changedItems) { myContext.getProgressIndicator().setText(CompilerBundle.message("packaging.compiler.message.deleting.outdated.files")); final boolean testMode = ApplicationManager.getApplication().isUnitTestMode(); @@ -349,20 +350,20 @@ public class ArtifactsCompilerInstance extends GenericCompilerInstance pathToDelete = new THashSet(); - for (GenericCompilerItemState item : changedItems) { - final ArtifactPackagingItemOutputState cached = item.getOutputState(); + for (GenericCompilerProcessingItem item : changedItems) { + final ArtifactPackagingItemOutputState cached = item.getCachedOutputState(); if (cached != null) { for (Pair destination : cached.myDestinations) { pathToDelete.add(destination.getFirst()); } } } - for (GenericCompilerItemState item : changedItems) { + for (GenericCompilerProcessingItem item : changedItems) { for (DestinationInfo destination : item.getItem().getDestinations()) { pathToDelete.remove(destination.getOutputPath()); } } - for (GenericCompilerItemState item : obsoleteItems) { + for (GenericCompilerCacheState item : obsoleteItems) { for (Pair destination : item.getOutputState().myDestinations) { pathToDelete.add(destination.getFirst()); }