FIX: Cannot invoke "com.intellij.psi.PsiFile.getProject()" because the return value of "net.seesharpsoft.intellij.plugins.csv.psi.CsvPsiTreeUpdater.getPsiFile()" is null #378

lazy initialization and additional null checks

Author: SeeSharpSoft

src/main/java/net/seesharpsoft/intellij/plugins/csv/psi/CsvPsiTreeUpdater.java

@@ -2,13 +2,11 @@
 
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.command.CommandProcessor;
-import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.fileTypes.FileType;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.*;
-import com.intellij.psi.impl.source.tree.LeafPsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.DocumentUtil;
 import net.seesharpsoft.intellij.plugins.csv.CsvHelper;
@@ -26,56 +24,62 @@
 
 public class CsvPsiTreeUpdater implements PsiFileHolder, Suspendable {
 
-    private final static Logger LOG = Logger.getInstance(CsvPsiTreeUpdater.class);
+    protected final EventListenerList myEventListenerList = new EventListenerList();
 
     private final PsiFileHolder myPsiFileHolder;
 
-    private final PsiFileFactory myFileFactory;
-
-    private final CsvPsiParserFileType myFileType;
+    private PsiFileFactory myFileFactory;
 
-    protected final EventListenerList myEventListenerList = new EventListenerList();
+    private CsvPsiParserFileType myFileType;
 
     private List<PsiAction> myUncommittedActions = new ArrayList<>();
 
     public CsvPsiTreeUpdater(@NotNull PsiFileHolder psiFileHolder) {
         myPsiFileHolder = psiFileHolder;
-        myFileFactory = PsiFileFactory.getInstance(getPsiFile().getProject());
-        myFileType = new CsvPsiParserFileType(CsvHelper.getValueSeparator(psiFileHolder.getPsiFile()), CsvHelper.getEscapeCharacter(psiFileHolder.getPsiFile()));
     }
 
     private FileType getFileType() {
-        myFileType.setSeparator(CsvHelper.getValueSeparator(getPsiFile()));
-        myFileType.setEscapeCharacter(CsvHelper.getEscapeCharacter(getPsiFile()));
+        PsiFile psiFile = getPsiFile();
+        if (psiFile == null) return null;
+
+        if (myFileType == null) {
+            myFileType = new CsvPsiParserFileType(CsvHelper.getValueSeparator(psiFile), CsvHelper.getEscapeCharacter(psiFile));
+        } else {
+            myFileType.setSeparator(CsvHelper.getValueSeparator(psiFile));
+            myFileType.setEscapeCharacter(CsvHelper.getEscapeCharacter(psiFile));
+        }
         return myFileType;
     }
 
+    private PsiFileFactory getFileFactory() {
+        PsiFile psiFile = getPsiFile();
+        if (psiFile == null) return null;
+
+        if (myFileFactory == null) {
+            myFileFactory = PsiFileFactory.getInstance(getPsiFile().getProject());
+        }
+        return myFileFactory;
+    }
+
     private PsiFile createFile(@NotNull String text) {
-        return myFileFactory.createFileFromText("a.csv", getFileType(), text);
+        PsiFileFactory fileFactory = getFileFactory();
+        return fileFactory == null ? null : getFileFactory().createFileFromText("a.csv", getFileType(), text);
     }
 
     private boolean isIndicatingComment(@NotNull String text) {
         return text.trim().startsWith(CsvEditorSettings.getInstance().getCommentIndicator());
     }
 
-    public @NotNull CsvField createField(@NotNull String text, boolean enquoteCommentIndicator) {
+    public @Nullable CsvField createField(@NotNull String text, boolean enquoteCommentIndicator) {
         boolean enforceQuoting = CsvEditorSettings.getInstance().isQuotingEnforced();
         if (enquoteCommentIndicator && isIndicatingComment(text)) enforceQuoting = true;
 
         String sanitizedValue = CsvHelper.quoteCsvField(text, CsvHelper.getEscapeCharacter(getPsiFile()), CsvHelper.getValueSeparator(getPsiFile()), enforceQuoting);
 
-        CsvField field = SyntaxTraverser.psiTraverser(createFile(sanitizedValue)).filter(CsvField.class).first();
-        if (field == null) {
-            LOG.warn(
-                    CsvHelper.formatString("Couldn't create field for text: ${sanitizedValue}",
-                            Collections.singletonMap("sanitizedValue", sanitizedValue))
-            );
-            field = (CsvField) CsvTypes.Factory.createElement(new LeafPsiElement(CsvTypes.FIELD, ""));
-        }
-        return field;
+        return SyntaxTraverser.psiTraverser(createFile(sanitizedValue)).filter(CsvField.class).first();
     }
 
-    public @NotNull CsvRecord createRecord() {
+    public @Nullable CsvRecord createRecord() {
         return SyntaxTraverser.psiTraverser(createFile("\n")).filter(CsvRecord.class).first();
     }
 
@@ -85,6 +89,8 @@ private boolean isIndicatingComment(@NotNull String text) {
 
     public Document getDocument() {
         PsiFile psiFile = getPsiFile();
+        if (psiFile == null) return null;
+
         return PsiDocumentManager.getInstance(psiFile.getProject()).getDocument(psiFile);
     }
 
@@ -332,6 +338,7 @@ public synchronized void commit() {
 
         suspend();
         List<PsiAction> actionsToCommit = new ArrayList<>(myUncommittedActions);
+        myUncommittedActions.clear();
         if (!doCommit(() -> {
             try {
                 actionsToCommit.forEach(PsiAction::execute);
@@ -341,16 +348,15 @@ public synchronized void commit() {
             }
         })) {
             resume();
-        } else {
-            myUncommittedActions.clear();
         }
     }
 
     private boolean doCommit(@NotNull Runnable runnable) {
-        if (!getPsiFile().isWritable()) return false;
-
+        PsiFile psiFile = getPsiFile();
         Document document = getDocument();
 
+        if (psiFile == null || !psiFile.isWritable() || document == null || !document.isWritable()) return false;
+
         ApplicationManager.getApplication().runWriteAction(() -> {
             CommandProcessor.getInstance().executeCommand(
                     getPsiFile().getProject(),
@@ -406,18 +412,20 @@ private static class AddSiblingPsiAction extends PsiAction {
         private final PsiElement myElementToAdd;
         private final boolean myBefore;
 
-        AddSiblingPsiAction(@NotNull PsiElement anchor, @NotNull PsiElement elementToAdd) {
+        AddSiblingPsiAction(@NotNull PsiElement anchor, @Nullable PsiElement elementToAdd) {
             this(anchor, elementToAdd, false);
         }
 
-        AddSiblingPsiAction(@NotNull PsiElement anchor, @NotNull PsiElement elementToAdd, boolean before) {
+        AddSiblingPsiAction(@NotNull PsiElement anchor, @Nullable PsiElement elementToAdd, boolean before) {
             super(anchor);
             myElementToAdd = elementToAdd;
             myBefore = before;
         }
 
         @Override
         public void execute() {
+            if (myElementToAdd == null) return;
+
             PsiElement anchor = getAnchor();
             if (anchor.getParent() == null) return;
             if (myBefore) {
@@ -432,13 +440,15 @@ private static class AddChildPsiAction extends PsiAction {
 
         private final PsiElement myElementToAdd;
 
-        AddChildPsiAction(@NotNull PsiElement parent, @NotNull PsiElement elementToAdd) {
+        AddChildPsiAction(@NotNull PsiElement parent, @Nullable PsiElement elementToAdd) {
             super(parent);
             myElementToAdd = elementToAdd;
         }
 
         @Override
         public void execute() {
+            if (myElementToAdd == null) return;
+
             PsiElement anchor = getAnchor();
             anchor.add(myElementToAdd);
         }
@@ -448,13 +458,15 @@ private static class ReplacePsiAction extends PsiAction {
 
         private final PsiElement myReplacement;
 
-        ReplacePsiAction(@NotNull PsiElement anchor, @NotNull PsiElement replacement) {
+        ReplacePsiAction(@NotNull PsiElement anchor, @Nullable PsiElement replacement) {
             super(anchor);
             myReplacement = replacement;
         }
 
         @Override
         public void execute() {
+            if (myReplacement == null) return;
+
             getAnchor().replace(myReplacement);
         }
     }
@@ -503,6 +515,8 @@ public void execute() {
 
             PsiDocumentManager manager = PsiDocumentManager.getInstance(psiFile.getProject());
             Document document = manager.getDocument(psiFile);
+            if (document == null) return;
+
             manager.doPostponedOperationsAndUnblockDocument(document);
 
             int offset = 0;

src/main/java/net/seesharpsoft/intellij/psi/PsiHelper.java

@@ -103,7 +103,7 @@ public static PsiElement getLastSiblingOfType(@NotNull final PsiElement element,
         return prevSibling == element ? null : prevSibling;
     }
 
-    public static PsiElement findFirst(@NotNull final PsiElement root, @NotNull IElementType type) {
+    public static PsiElement findFirst(@Nullable final PsiElement root, @NotNull IElementType type) {
         return SyntaxTraverser.psiTraverser(root).filterTypes(elementType -> elementType == type).filter(PsiElement.class).first();
     }
 

src/main/java/net/seesharpsoft/intellij/util/Suspendable.java

@@ -28,7 +28,7 @@ default void dispose() {
     class SuspensionMonitor {
         private final Map<Suspendable, Integer> suspendableCounterMap = new ConcurrentHashMap<>();
 
-        private Integer getSuspendableCounter(Suspendable suspendable) {
+        private synchronized Integer getSuspendableCounter(Suspendable suspendable) {
             if (suspendableCounterMap.containsKey(suspendable)) return suspendableCounterMap.get(suspendable);
             return null;
         }