platform/lang-impl/src/com/intellij/psi/impl/PsiFileFactoryImpl.java

   1 /*
   2  * @author max
   3  */
   4 package com.intellij.psi.impl;
   5
   6 import com.intellij.lang.Language;
   7 import com.intellij.lang.LanguageParserDefinitions;
   8 import com.intellij.lang.ParserDefinition;
   9 import com.intellij.openapi.diagnostic.Logger;
  10 import com.intellij.openapi.fileTypes.FileType;
  11 import com.intellij.openapi.fileTypes.FileTypeManager;
  12 import com.intellij.openapi.fileTypes.LanguageFileType;
  13 import com.intellij.psi.*;
  14 import com.intellij.psi.impl.source.PsiPlainTextFileImpl;
  15 import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
  16 import com.intellij.psi.impl.source.tree.TreeElement;
  17 import com.intellij.testFramework.LightVirtualFile;
  18 import com.intellij.util.LocalTimeCounter;
  19 import com.intellij.util.text.CharSequenceSubSequence;
  20 import org.jetbrains.annotations.NotNull;
  21 import org.jetbrains.annotations.Nullable;
  22
  23 public class PsiFileFactoryImpl extends PsiFileFactory {
  24   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.PsiFileFactoryImpl");
  25   private final PsiManager myManager;
  26
  27   public PsiFileFactoryImpl(final PsiManager manager) {
  28     myManager = manager;
  29   }
  30
  31   @NotNull
  32   public PsiFile createFileFromText(@NotNull String name, @NotNull FileType fileType, @NotNull CharSequence text,
  33                                     long modificationStamp, final boolean physical) {
  34     return createFileFromText(name, fileType, text, modificationStamp, physical, true);
  35   }
  36
  37   public PsiFile createFileFromText(@NotNull String name, @NotNull Language language, @NotNull CharSequence text) {
  38     return createFileFromText(name, language, text, true, true);
  39   }
  40
  41   public PsiFile createFileFromText(@NotNull String name, @NotNull Language language, @NotNull CharSequence text, boolean physical,
  42                                     final boolean markAsCopy) {
  43     return trySetupPsiForFile(new LightVirtualFile(name, language, text), language, physical, markAsCopy);
  44   }
  45
  46   @NotNull
  47   public PsiFile createFileFromText(@NotNull String name,
  48                                     @NotNull FileType fileType,
  49                                     @NotNull CharSequence text,
  50                                     long modificationStamp,
  51                                     final boolean physical,
  52                                     boolean markAsCopy) {
  53     final LightVirtualFile virtualFile = new LightVirtualFile(name, fileType, text, modificationStamp);
  54     if(fileType instanceof LanguageFileType){
  55       final Language language =
  56           LanguageSubstitutors.INSTANCE.substituteLanguage(((LanguageFileType)fileType).getLanguage(), virtualFile, myManager.getProject());
  57       final PsiFile file = trySetupPsiForFile(virtualFile, language, physical, markAsCopy);
  58       if (file != null) return file;
  59     }
  60     final SingleRootFileViewProvider singleRootFileViewProvider =
  61       new SingleRootFileViewProvider(myManager, virtualFile, physical);
  62     final PsiPlainTextFileImpl plainTextFile = new PsiPlainTextFileImpl(singleRootFileViewProvider);
  63     if(markAsCopy) CodeEditUtil.setNodeGenerated(plainTextFile.getNode(), true);
  64     return plainTextFile;
  65   }
  66
  67   @Nullable
  68   private PsiFile trySetupPsiForFile(final LightVirtualFile virtualFile, Language language,
  69                                      final boolean physical, final boolean markAsCopy) {
  70     final FileViewProviderFactory factory = LanguageFileViewProviders.INSTANCE.forLanguage(language);
  71     FileViewProvider viewProvider = factory != null ? factory.createFileViewProvider(virtualFile, language, myManager, physical) : null;
  72     if (viewProvider == null) viewProvider = new SingleRootFileViewProvider(myManager, virtualFile, physical);
  73
  74     language = viewProvider.getBaseLanguage();
  75     final ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(language);
  76     if (parserDefinition != null) {
  77       final PsiFile psiFile = viewProvider.getPsi(language);
  78       if (psiFile != null) {
  79         if (markAsCopy) {
  80           final TreeElement node = (TreeElement)psiFile.getNode();
  81           assert node != null;
  82           node.acceptTree(new GeneratedMarkerVisitor());
  83         }
  84         return psiFile;
  85       }
  86     }
  87     return null;
  88   }
  89
  90   @NotNull
  91   public PsiFile createFileFromText(@NotNull String name,
  92                                     @NotNull FileType fileType, final Language language, @NotNull Language targetLanguage, @NotNull CharSequence text,
  93                                     long modificationStamp,
  94                                     final boolean physical,
  95                                     boolean markAsCopy) {
  96     final LightVirtualFile virtualFile = new LightVirtualFile(name, fileType, text, modificationStamp);
  97
  98     final ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(language);
  99     final FileViewProviderFactory factory = LanguageFileViewProviders.INSTANCE.forLanguage(language);
 100     FileViewProvider viewProvider = factory != null ? factory.createFileViewProvider(virtualFile, language, myManager, physical) : null;
 101     if (viewProvider == null) viewProvider = new SingleRootFileViewProvider(myManager, virtualFile, physical);
 102
 103     if (parserDefinition != null){
 104       final PsiFile psiFile = viewProvider.getPsi(targetLanguage);
 105       if (psiFile != null) {
 106         if(markAsCopy) {
 107           final TreeElement node = (TreeElement)psiFile.getNode();
 108           assert node != null;
 109           node.acceptTree(new GeneratedMarkerVisitor());
 110         }
 111         return psiFile;
 112       }
 113     }
 114
 115     final SingleRootFileViewProvider singleRootFileViewProvider =
 116         new SingleRootFileViewProvider(myManager, virtualFile, physical);
 117     final PsiPlainTextFileImpl plainTextFile = new PsiPlainTextFileImpl(singleRootFileViewProvider);
 118     if(markAsCopy) CodeEditUtil.setNodeGenerated(plainTextFile.getNode(), true);
 119     return plainTextFile;
 120   }
 121
 122   @NotNull
 123   public PsiFile createFileFromText(@NotNull String name, @NotNull FileType fileType, @NotNull CharSequence text) {
 124     return createFileFromText(name, fileType, text, LocalTimeCounter.currentTime(), false);
 125   }
 126
 127   @NotNull
 128   public PsiFile createFileFromText(@NotNull String name, @NotNull String text){
 129     FileTypeManager fileTypeManager = FileTypeManager.getInstance();
 130     FileType type = fileTypeManager.getFileTypeByFileName(name);
 131     if (type.isBinary()) {
 132       throw new RuntimeException("Cannot create binary files from text");
 133     }
 134
 135     return createFileFromText(name, type, text);
 136   }
 137
 138   public PsiFile createFileFromText(FileType fileType, final String fileName, CharSequence chars, int startOffset, int endOffset) {
 139     LOG.assertTrue(!fileType.isBinary());
 140     final CharSequence text = startOffset == 0 && endOffset == chars.length()?chars:new CharSequenceSubSequence(chars, startOffset, endOffset);
 141     return createFileFromText(fileName, fileType, text);
 142   }
 143
 144   @Nullable
 145   @Override
 146   public PsiFile createFileFromText(@NotNull CharSequence chars, @NotNull PsiFile original) {
 147     final PsiFile file = createFileFromText(original.getName(), original.getLanguage(), chars, false, true);
 148     if (file != null) {
 149       file.putUserData(ORIGINAL_FILE, original);
 150     }
 151     return file;
 152   }
 153 }