java/java-impl/src/com/intellij/psi/impl/PsiElementFactoryImpl.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.psi.impl;
  17
  18 import com.intellij.lang.*;
  19 import com.intellij.lexer.Lexer;
  20 import com.intellij.openapi.diagnostic.Logger;
  21 import com.intellij.openapi.project.Project;
  22 import com.intellij.pom.java.LanguageLevel;
  23 import com.intellij.psi.*;
  24 import com.intellij.psi.codeStyle.CodeStyleManager;
  25 import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
  26 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
  27 import com.intellij.psi.impl.light.*;
  28 import com.intellij.psi.impl.source.*;
  29 import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
  30 import com.intellij.psi.impl.source.tree.*;
  31 import com.intellij.psi.javadoc.PsiDocTag;
  32 import com.intellij.psi.search.GlobalSearchScope;
  33 import com.intellij.psi.tree.IElementType;
  34 import com.intellij.psi.util.PsiUtil;
  35 import com.intellij.util.IncorrectOperationException;
  36 import com.intellij.util.containers.HashMap;
  37 import org.jetbrains.annotations.NonNls;
  38 import org.jetbrains.annotations.NotNull;
  39 import org.jetbrains.annotations.Nullable;
  40
  41 import java.util.Map;
  42
  43 public class PsiElementFactoryImpl extends PsiJavaParserFacadeImpl implements PsiElementFactory {
  44   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.PsiElementFactoryImpl");
  45
  46   private PsiClass ARRAY_CLASS;
  47   private PsiClass ARRAY_CLASS15;
  48
  49   static {
  50     initPrimitiveTypes();
  51   }
  52
  53   private static void initPrimitiveTypes() {
  54     ourPrimitiveTypesMap.put(PsiType.BYTE.getCanonicalText(), (PsiPrimitiveType)PsiType.BYTE);
  55     ourPrimitiveTypesMap.put(PsiType.CHAR.getCanonicalText(), (PsiPrimitiveType)PsiType.CHAR);
  56     ourPrimitiveTypesMap.put(PsiType.DOUBLE.getCanonicalText(), (PsiPrimitiveType)PsiType.DOUBLE);
  57     ourPrimitiveTypesMap.put(PsiType.FLOAT.getCanonicalText(), (PsiPrimitiveType)PsiType.FLOAT);
  58     ourPrimitiveTypesMap.put(PsiType.INT.getCanonicalText(), (PsiPrimitiveType)PsiType.INT);
  59     ourPrimitiveTypesMap.put(PsiType.LONG.getCanonicalText(), (PsiPrimitiveType)PsiType.LONG);
  60     ourPrimitiveTypesMap.put(PsiType.SHORT.getCanonicalText(), (PsiPrimitiveType)PsiType.SHORT);
  61     ourPrimitiveTypesMap.put(PsiType.BOOLEAN.getCanonicalText(), (PsiPrimitiveType)PsiType.BOOLEAN);
  62     ourPrimitiveTypesMap.put(PsiType.VOID.getCanonicalText(), (PsiPrimitiveType)PsiType.VOID);
  63     ourPrimitiveTypesMap.put(PsiType.NULL.getCanonicalText(), (PsiPrimitiveType)PsiType.NULL);
  64   }
  65
  66   public PsiElementFactoryImpl(PsiManagerEx manager) {
  67     super(manager);
  68   }
  69
  70   public PsiJavaFile getDummyJavaFile() {
  71     if (myDummyJavaFile == null) {
  72       myDummyJavaFile = createDummyJavaFile("");
  73     }
  74
  75     return myDummyJavaFile;
  76   }
  77
  78   @NotNull
  79   public PsiClass getArrayClass(@NotNull LanguageLevel languageLevel) {
  80     try {
  81       if (languageLevel.compareTo(LanguageLevel.JDK_1_5) < 0) {
  82         if (ARRAY_CLASS == null) {
  83           ARRAY_CLASS = createClassFromText("public class __Array__{\n public final int length; \n public Object clone(){}\n}", null).getInnerClasses()[0];
  84         }
  85         return ARRAY_CLASS;
  86       }
  87       else {
  88         if (ARRAY_CLASS15 == null) {
  89           ARRAY_CLASS15 = createClassFromText("public class __Array__<T>{\n public final int length; \n public T[] clone(){}\n}", null).getInnerClasses()[0];
  90         }
  91         return ARRAY_CLASS15;
  92       }
  93     }
  94     catch (IncorrectOperationException e) {
  95       LOG.error(e);
  96       return null;
  97     }
  98   }
  99
 100   @NotNull
 101   public PsiClassType getArrayClassType(@NotNull PsiType componentType, @NotNull final LanguageLevel languageLevel) {
 102     PsiClass arrayClass = getArrayClass(languageLevel);
 103     PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
 104     PsiTypeParameter[] typeParameters = arrayClass.getTypeParameters();
 105     if (typeParameters.length == 1) {
 106       substitutor = substitutor.put(typeParameters[0], componentType);
 107     }
 108
 109     return createType(arrayClass, substitutor);
 110   }
 111
 112   @NotNull
 113   public PsiClassType createType(@NotNull PsiClass resolve, @NotNull PsiSubstitutor substitutor) {
 114     return new PsiImmediateClassType(resolve, substitutor);
 115   }
 116
 117   @NotNull
 118   public PsiClassType createType(@NotNull PsiClass resolve, @NotNull PsiSubstitutor substitutor, @NotNull LanguageLevel languageLevel) {
 119     return new PsiImmediateClassType(resolve, substitutor, languageLevel);
 120   }
 121
 122   @NotNull
 123   public PsiClassType createType(@NotNull PsiClass resolve,
 124                                  @NotNull PsiSubstitutor substitutor,
 125                                  @NotNull LanguageLevel languageLevel,
 126                                  @NotNull PsiAnnotation[] annotations) {
 127     return new PsiImmediateClassType(resolve, substitutor, languageLevel, annotations);
 128   }
 129
 130   @NotNull
 131   public PsiClass createClass(@NotNull String name) throws IncorrectOperationException {
 132     PsiUtil.checkIsIdentifier(myManager, name);
 133     @NonNls String text = "public class " + name + "{ }";
 134     PsiJavaFile aFile = createDummyJavaFile(text);
 135     PsiClass[] classes = aFile.getClasses();
 136     if (classes.length != 1) {
 137       throw new IncorrectOperationException();
 138     }
 139     return classes[0];
 140   }
 141
 142   @NotNull
 143   public PsiClass createInterface(@NotNull String name) throws IncorrectOperationException {
 144     PsiUtil.checkIsIdentifier(myManager, name);
 145     @NonNls String text = "public interface " + name + "{ }";
 146     PsiJavaFile aFile = createDummyJavaFile(text);
 147     PsiClass[] classes = aFile.getClasses();
 148     if (classes.length != 1) {
 149       throw new IncorrectOperationException();
 150     }
 151     return classes[0];
 152   }
 153
 154   public PsiClass createEnum(@NotNull final String name) throws IncorrectOperationException {
 155     PsiUtil.checkIsIdentifier(myManager, name);
 156     @NonNls String text = "public enum " + name + "{ }";
 157     PsiJavaFile aFile = createDummyJavaFile(text);
 158     PsiClass[] classes = aFile.getClasses();
 159     if (classes.length != 1) {
 160       throw new IncorrectOperationException();
 161     }
 162     return classes[0];
 163   }
 164
 165   @NotNull
 166   public PsiTypeElement createTypeElement(@NotNull PsiType psiType) {
 167     final LightTypeElement element = new LightTypeElement(myManager, psiType);
 168     CodeEditUtil.setNodeGenerated(element.getNode(), true);
 169     return element;
 170   }
 171
 172   @NotNull
 173   public PsiJavaCodeReferenceElement createReferenceElementByType(@NotNull PsiClassType type) {
 174     if (type instanceof PsiClassReferenceType) {
 175       return ((PsiClassReferenceType)type).getReference();
 176     }
 177
 178     final PsiClassType.ClassResolveResult resolveResult = type.resolveGenerics();
 179     return new LightClassReference(myManager, type.getPresentableText(), resolveResult.getElement(), resolveResult.getSubstitutor());
 180   }
 181
 182   @NotNull
 183   public PsiField createField(@NotNull String name, @NotNull PsiType type) throws IncorrectOperationException {
 184     PsiUtil.checkIsIdentifier(myManager, name);
 185     if (PsiType.NULL.equals(type)) {
 186       throw new IncorrectOperationException("Cannot create field with type \"<null_type>\".");
 187     }
 188     TreeElement typeCopy = ChangeUtil.copyToElement(createTypeElement(type));
 189     typeCopy.acceptTree(new GeneratedMarkerVisitor());
 190     @NonNls String text = "class _Dummy_ {private int " + name + ";}";
 191     PsiJavaFile aFile = createDummyJavaFile(text);
 192     PsiClass aClass = aFile.getClasses()[0];
 193     PsiField field = aClass.getFields()[0];
 194     SourceTreeToPsiMap.psiElementToTree(field).replaceChild(SourceTreeToPsiMap.psiElementToTree(field.getTypeElement()), typeCopy);
 195     ChangeUtil.decodeInformation((TreeElement)SourceTreeToPsiMap.psiElementToTree(field));
 196     return (PsiField)CodeStyleManager.getInstance(myManager.getProject()).reformat(field);
 197   }
 198
 199   @NotNull
 200   public PsiMethod createMethod(@NotNull String name, PsiType returnType) throws IncorrectOperationException {
 201     PsiUtil.checkIsIdentifier(myManager, name);
 202     if (PsiType.NULL.equals(returnType)) {
 203       throw new IncorrectOperationException("Cannot create field with type \"<null_type>\".");
 204     }
 205     @NonNls String text = "class _Dummy_ {\n public " + returnType.getCanonicalText() + " " + name + "(){}\n}";
 206     PsiJavaFile aFile = createDummyJavaFile(text);
 207     PsiClass aClass = aFile.getClasses()[0];
 208     PsiMethod method = aClass.getMethods()[0];
 209     JavaCodeStyleManager.getInstance(myManager.getProject()).shortenClassReferences(method);
 210     return (PsiMethod)CodeStyleManager.getInstance(myManager.getProject()).reformat(method);
 211   }
 212
 213   @NotNull
 214   public PsiMethod createConstructor() {
 215     try {
 216       @NonNls String text = "class _Dummy_ {\n public _Dummy_(){}\n}";
 217       PsiJavaFile aFile = createDummyJavaFile(text);
 218       PsiClass aClass = aFile.getClasses()[0];
 219       PsiMethod method = aClass.getMethods()[0];
 220       return (PsiMethod)CodeStyleManager.getInstance(myManager.getProject()).reformat(method);
 221     }
 222     catch (IncorrectOperationException e) {
 223       LOG.assertTrue(false);
 224       return null;
 225     }
 226   }
 227
 228   @NotNull
 229   public PsiClassInitializer createClassInitializer() throws IncorrectOperationException {
 230     @NonNls String text = "class _Dummy_ { {} }";
 231     final PsiJavaFile aFile = createDummyJavaFile(text);
 232     final PsiClass aClass = aFile.getClasses()[0];
 233     final PsiClassInitializer psiClassInitializer = aClass.getInitializers()[0];
 234     return (PsiClassInitializer)CodeStyleManager.getInstance(myManager.getProject()).reformat(psiClassInitializer);
 235   }
 236
 237   @NotNull
 238   public PsiParameter createParameter(@NotNull String name, @NotNull PsiType type) throws IncorrectOperationException {
 239     PsiUtil.checkIsIdentifier(myManager, name);
 240     if (PsiType.NULL.equals(type)) {
 241       throw new IncorrectOperationException("Cannot create field with type \"<null_type>\".");
 242     }
 243     final FileElement treeHolder = DummyHolderFactory.createHolder(myManager, null).getTreeElement();
 244     final CompositeElement treeElement =
 245     getJavaParsingContext(treeHolder).getDeclarationParsing().parseParameterText(type.getCanonicalText() + " " + name);
 246     treeHolder.rawAddChildren(treeElement);
 247
 248     CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(myManager.getProject());
 249     PsiParameter parameter = (PsiParameter)SourceTreeToPsiMap.treeElementToPsi(treeElement);
 250     PsiUtil.setModifierProperty(parameter, PsiModifier.FINAL, CodeStyleSettingsManager.getSettings(myManager.getProject()).GENERATE_FINAL_PARAMETERS);
 251     treeElement.acceptTree(new GeneratedMarkerVisitor());
 252     JavaCodeStyleManager.getInstance(myManager.getProject()).shortenClassReferences(parameter);
 253     return (PsiParameter)codeStyleManager.reformat(parameter);
 254   }
 255
 256   @NotNull
 257   public PsiCodeBlock createCodeBlock() {
 258     try {
 259       PsiCodeBlock block = createCodeBlockFromText("{}", null);
 260       return (PsiCodeBlock)CodeStyleManager.getInstance(myManager.getProject()).reformat(block);
 261     }
 262     catch (IncorrectOperationException e) {
 263       LOG.error(e);
 264       return null;
 265     }
 266   }
 267
 268   @NotNull
 269   public PsiClassType createType(@NotNull PsiClass aClass) {
 270     return new PsiImmediateClassType(aClass, aClass instanceof PsiTypeParameter ? PsiSubstitutor.EMPTY : createRawSubstitutor(aClass));
 271   }
 272
 273   @NotNull
 274   public PsiClassType createType(@NotNull PsiJavaCodeReferenceElement classReference) {
 275     return new PsiClassReferenceType(classReference, null);
 276   }
 277
 278   private static class TypeDetacher extends PsiTypeVisitor<PsiType> {
 279     public static final TypeDetacher INSTANCE = new TypeDetacher();
 280
 281     public PsiType visitType(PsiType type) {
 282       return type;
 283     }
 284
 285     public PsiType visitWildcardType(PsiWildcardType wildcardType) {
 286       final PsiType bound = wildcardType.getBound();
 287       if (bound == null) {
 288         return wildcardType;
 289       }
 290       else {
 291         return PsiWildcardType.changeBound(wildcardType, bound.accept(this));
 292       }
 293     }
 294
 295     public PsiType visitArrayType(PsiArrayType arrayType) {
 296       final PsiType componentType = arrayType.getComponentType();
 297       final PsiType detachedComponentType = componentType.accept(this);
 298       if (detachedComponentType == componentType) return arrayType; // optimization
 299       return detachedComponentType.createArrayType();
 300     }
 301
 302     public PsiType visitClassType(PsiClassType classType) {
 303       final PsiClassType.ClassResolveResult resolveResult = classType.resolveGenerics();
 304       final PsiClass aClass = resolveResult.getElement();
 305       if (aClass == null) return classType;
 306       final HashMap<PsiTypeParameter, PsiType> map = new HashMap<PsiTypeParameter, PsiType>();
 307       for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(aClass)) {
 308         PsiType type = resolveResult.getSubstitutor().substitute(parameter);
 309         if (type != null) {
 310           type = type.accept(this);
 311         }
 312         map.put(parameter, type);
 313       }
 314       return new PsiImmediateClassType(aClass, PsiSubstitutorImpl.createSubstitutor(map));
 315     }
 316   }
 317
 318
 319   @NotNull
 320   public PsiType detachType(@NotNull PsiType type) {
 321     return type.accept(TypeDetacher.INSTANCE);
 322   }
 323
 324   @NotNull
 325   public PsiSubstitutor createRawSubstitutor(@NotNull PsiTypeParameterListOwner owner) {
 326     Map<PsiTypeParameter, PsiType> substMap = null;
 327     for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(owner)) {
 328       if (substMap == null) substMap = new HashMap<PsiTypeParameter, PsiType>();
 329       substMap.put(parameter, null);
 330     }
 331     return PsiSubstitutorImpl.createSubstitutor(substMap);
 332   }
 333   @NotNull
 334   public PsiSubstitutor createRawSubstitutor(@NotNull PsiSubstitutor baseSubstitutor, @NotNull PsiTypeParameter[] typeParameters) {
 335     Map<PsiTypeParameter, PsiType> substMap = null;
 336     for (PsiTypeParameter parameter : typeParameters) {
 337       if (substMap == null) substMap = new HashMap<PsiTypeParameter, PsiType>();
 338       substMap.put(parameter, null);
 339     }
 340     return baseSubstitutor.putAll(PsiSubstitutorImpl.createSubstitutor(substMap));
 341   }
 342
 343   @NotNull
 344   public PsiElement createDummyHolder(@NotNull String text, @NotNull IElementType type, @Nullable PsiElement context) {
 345     final DummyHolder result = DummyHolderFactory.createHolder(myManager, context);
 346     final FileElement holder = result.getTreeElement();
 347     final Language language = type.getLanguage();
 348     final ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(language);
 349     if (parserDefinition == null) {
 350       throw new AssertionError("No parser definition for language " + language);
 351     }
 352     final Project project = myManager.getProject();
 353     final Lexer lexer = parserDefinition.createLexer(project);
 354     final PsiBuilder builder = PsiBuilderFactory.getInstance().createBuilder(project, holder, lexer, language, text);
 355     final ASTNode node = parserDefinition.createParser(project).parse(type, builder);
 356     holder.rawAddChildren((TreeElement)node);
 357     return node.getPsi();
 358   }
 359
 360   @NotNull
 361   public PsiSubstitutor createSubstitutor(@NotNull Map<PsiTypeParameter, PsiType> map) {
 362     return PsiSubstitutorImpl.createSubstitutor(map);
 363   }
 364
 365   @Nullable
 366   public PsiPrimitiveType createPrimitiveType(@NotNull String text) {
 367     return getPrimitiveType(text);
 368   }
 369
 370   public static PsiPrimitiveType getPrimitiveType(final String text) {
 371     return ourPrimitiveTypesMap.get(text);
 372   }
 373
 374   @NotNull
 375   public PsiClassType createTypeByFQClassName(@NotNull String qName) {
 376     return createTypeByFQClassName(qName, GlobalSearchScope.allScope(myManager.getProject()));
 377   }
 378
 379   @NotNull
 380   public PsiClassType createTypeByFQClassName(@NotNull String qName, @NotNull GlobalSearchScope resolveScope) {
 381     return new PsiClassReferenceType(createReferenceElementByFQClassName(qName, resolveScope), null);
 382   }
 383
 384   @NotNull
 385   public PsiJavaCodeReferenceElement createClassReferenceElement(@NotNull PsiClass aClass) {
 386     final String text;
 387     if (aClass instanceof PsiAnonymousClass) {
 388       text = ((PsiAnonymousClass)aClass).getBaseClassType().getPresentableText();
 389     }
 390     else {
 391       text = aClass.getName();
 392     }
 393     return new LightClassReference(myManager, text, aClass);
 394   }
 395
 396   @NotNull
 397   public PsiJavaCodeReferenceElement createReferenceElementByFQClassName(@NotNull String qName, @NotNull GlobalSearchScope resolveScope) {
 398     String shortName = PsiNameHelper.getShortClassName(qName);
 399     return new LightClassReference(myManager, shortName, qName, resolveScope);
 400   }
 401
 402   @NotNull
 403   public PsiJavaCodeReferenceElement createFQClassNameReferenceElement(@NotNull String qName, @NotNull GlobalSearchScope resolveScope) {
 404     return new LightClassReference(myManager, qName, qName, resolveScope);
 405   }
 406
 407   @NotNull
 408   public PsiJavaCodeReferenceElement createPackageReferenceElement(@NotNull PsiPackage aPackage)
 409     throws IncorrectOperationException {
 410     if (aPackage.getQualifiedName().length() == 0) {
 411       throw new IncorrectOperationException("Cannot create reference to default package.");
 412     }
 413     return new LightPackageReference(myManager, aPackage);
 414   }
 415
 416   @NotNull
 417   public PsiPackageStatement createPackageStatement(@NotNull String name) throws IncorrectOperationException {
 418     final PsiJavaFile javaFile = (PsiJavaFile)PsiFileFactory.getInstance(myManager.getProject()).createFileFromText("dummy.java", "package " + name + ";");
 419     final PsiPackageStatement stmt = javaFile.getPackageStatement();
 420     if (stmt == null) throw new IncorrectOperationException("Incorrect package name: " + name);
 421     return stmt;
 422   }
 423
 424   @NotNull
 425   public PsiJavaCodeReferenceCodeFragment createReferenceCodeFragment(@NotNull String text,
 426                                                                       PsiElement context,
 427                                                                       boolean isPhysical,
 428                                                                       boolean isClassesAccepted) {
 429     final PsiJavaCodeReferenceCodeFragmentImpl result =
 430       new PsiJavaCodeReferenceCodeFragmentImpl(myManager.getProject(), isPhysical, "fragment.java", text, isClassesAccepted);
 431     result.setContext(context);
 432     return result;
 433   }
 434
 435   @NotNull
 436   public PsiImportStaticStatement createImportStaticStatement(@NotNull PsiClass aClass, @NotNull String memberName) throws IncorrectOperationException {
 437     if (aClass instanceof PsiAnonymousClass) {
 438       throw new IncorrectOperationException("Cannot create import statement for anonymous class.");
 439     }
 440     else if (aClass.getParent() instanceof PsiDeclarationStatement) {
 441       throw new IncorrectOperationException("Cannot create import statement for local class.");
 442     }
 443     @NonNls String text = "import static " + aClass.getQualifiedName() + "." + memberName + ";";
 444     PsiJavaFile aFile = createDummyJavaFile(text);
 445     PsiImportStaticStatement statement = aFile.getImportList().getImportStaticStatements()[0];
 446     return (PsiImportStaticStatement)CodeStyleManager.getInstance(myManager.getProject()).reformat(statement);
 447   }
 448
 449   @NotNull
 450   public PsiParameterList createParameterList(@NotNull String[] names, @NotNull PsiType[] types) throws IncorrectOperationException {
 451     @NonNls String text = "void method(";
 452     String sep = "";
 453     for (int i = 0; i < names.length; i++) {
 454       final String name = names[i];
 455       PsiType type = types[i];
 456       text += sep + type.getCanonicalText() + " " + name;
 457       sep = ",";
 458     }
 459     text += "){}";
 460     PsiMethod method = createMethodFromText(text, null);
 461     return method.getParameterList();
 462   }
 463
 464   @NotNull
 465   public PsiReferenceList createReferenceList(@NotNull PsiJavaCodeReferenceElement[] references) throws IncorrectOperationException {
 466     @NonNls String text = "void method() ";
 467     if (references.length > 0) text += "throws ";
 468     String sep = "";
 469     for (final PsiJavaCodeReferenceElement reference : references) {
 470       text += sep + reference.getCanonicalText();
 471       sep = ",";
 472     }
 473     text += "{}";
 474     PsiMethod method = createMethodFromText(text, null);
 475     return method.getThrowsList();
 476   }
 477
 478   @NotNull
 479   public PsiJavaCodeReferenceElement createPackageReferenceElement(@NotNull String packageName)
 480     throws IncorrectOperationException {
 481     if (packageName.length() == 0) {
 482       throw new IncorrectOperationException("Cannot create reference to default package.");
 483     }
 484     return new LightPackageReference(myManager, packageName);
 485   }
 486
 487   @NotNull
 488   public PsiReferenceExpression createReferenceExpression(@NotNull PsiClass aClass) throws IncorrectOperationException {
 489     String text;
 490     if (aClass instanceof PsiAnonymousClass) {
 491       text = ((PsiAnonymousClass)aClass).getBaseClassType().getPresentableText();
 492     }
 493     else {
 494       text = aClass.getName();
 495     }
 496     return new LightClassReferenceExpression(myManager, text, aClass);
 497   }
 498
 499   @NotNull
 500   public PsiReferenceExpression createReferenceExpression(@NotNull PsiPackage aPackage) throws IncorrectOperationException {
 501     if (aPackage.getQualifiedName().length() == 0) {
 502       throw new IncorrectOperationException("Cannot create reference to default package.");
 503     }
 504     return new LightPackageReferenceExpression(myManager, aPackage);
 505   }
 506
 507   @NotNull
 508   public PsiIdentifier createIdentifier(@NotNull String text) throws IncorrectOperationException {
 509     PsiUtil.checkIsIdentifier(myManager, text);
 510     return new LightIdentifier(myManager, text);
 511   }
 512
 513   @NotNull
 514   public PsiKeyword createKeyword(@NotNull String text) throws IncorrectOperationException {
 515     if (!JavaPsiFacade.getInstance(myManager.getProject()).getNameHelper().isKeyword(text)) {
 516       throw new IncorrectOperationException("\"" + text + "\" is not a keyword.");
 517     }
 518     return new LightKeyword(myManager, text);
 519   }
 520
 521   @NotNull
 522   public PsiImportStatement createImportStatement(@NotNull PsiClass aClass) throws IncorrectOperationException {
 523     if (aClass instanceof PsiAnonymousClass) {
 524       throw new IncorrectOperationException("Cannot create import statement for anonymous class.");
 525     }
 526     else if (aClass.getParent() instanceof PsiDeclarationStatement) {
 527       throw new IncorrectOperationException("Cannot create import statement for local class.");
 528     }
 529     @NonNls String text = "import " + aClass.getQualifiedName() + ";";
 530     PsiJavaFile aFile = createDummyJavaFile(text);
 531     PsiImportStatement statement = aFile.getImportList().getImportStatements()[0];
 532     return (PsiImportStatement)CodeStyleManager.getInstance(myManager.getProject()).reformat(statement);
 533   }
 534
 535   @NotNull
 536   public PsiImportStatement createImportStatementOnDemand(@NotNull String packageName) throws IncorrectOperationException {
 537     if (packageName.length() == 0) {
 538       throw new IncorrectOperationException("Cannot create import statement for default package.");
 539     }
 540     if (!JavaPsiFacade.getInstance(myManager.getProject()).getNameHelper().isQualifiedName(packageName)) {
 541       throw new IncorrectOperationException("Incorrect package name: \"" + packageName + "\".");
 542     }
 543
 544     @NonNls String text = "import " + packageName + ".*;";
 545     PsiJavaFile aFile = createDummyJavaFile(text);
 546     PsiImportStatement statement = aFile.getImportList().getImportStatements()[0];
 547     return (PsiImportStatement)CodeStyleManager.getInstance(myManager.getProject()).reformat(statement);
 548   }
 549
 550   @NotNull
 551   public PsiDeclarationStatement createVariableDeclarationStatement(@NotNull String name, @NotNull PsiType type, PsiExpression initializer)
 552     throws IncorrectOperationException {
 553     if (!JavaPsiFacade.getInstance(myManager.getProject()).getNameHelper().isIdentifier(name)) {
 554       throw new IncorrectOperationException("\"" + name + "\" is not an identifier.");
 555     }
 556     if (PsiType.NULL.equals(type)) {
 557       throw new IncorrectOperationException("Cannot create field with type \"<null_type>\".");
 558     }
 559     @NonNls StringBuilder buffer = new StringBuilder();
 560     buffer.append("X ");
 561     buffer.append(name);
 562     if (initializer != null) {
 563       buffer.append("=x");
 564     }
 565     buffer.append(";");
 566     PsiDeclarationStatement statement = (PsiDeclarationStatement)createStatementFromText(buffer.toString(), null);
 567     PsiVariable variable = (PsiVariable)statement.getDeclaredElements()[0];
 568     variable.getTypeElement().replace(createTypeElement(type));
 569     PsiUtil.setModifierProperty(variable, PsiModifier.FINAL, CodeStyleSettingsManager.getSettings(myManager.getProject()).GENERATE_FINAL_LOCALS);
 570     if (initializer != null) {
 571       variable.getInitializer().replace(initializer);
 572     }
 573     markGenerated(statement);
 574     return statement;
 575
 576   }
 577
 578   @NotNull
 579   public PsiDocTag createParamTag(@NotNull String parameterName, @NonNls String description) throws IncorrectOperationException {
 580     @NonNls StringBuilder buffer = new StringBuilder();
 581     buffer.append(" * @param ");
 582     buffer.append(parameterName);
 583     buffer.append(" ");
 584     final String[] strings = description.split("\\n");
 585     for (int i = 0; i < strings.length; i++) {
 586       String string = strings[i];
 587       if (i > 0) buffer.append("\n * ");
 588       buffer.append(string);
 589     }
 590     return createDocTagFromText(buffer.toString(), null);
 591   }
 592
 593   @NotNull
 594   public PsiExpressionCodeFragment createExpressionCodeFragment(@NotNull String text,
 595                                                                 PsiElement context,
 596                                                                 final PsiType expectedType,
 597                                                                 boolean isPhysical) {
 598     final PsiExpressionCodeFragmentImpl result = new PsiExpressionCodeFragmentImpl(
 599     myManager.getProject(), isPhysical, "fragment.java", text, expectedType);
 600     result.setContext(context);
 601     return result;
 602   }
 603
 604   @NotNull
 605   public JavaCodeFragment createCodeBlockCodeFragment(@NotNull String text, PsiElement context, boolean isPhysical) {
 606     final PsiCodeFragmentImpl result = new PsiCodeFragmentImpl(myManager.getProject(), JavaElementType.STATEMENTS,
 607                                                                isPhysical,
 608                                                                "fragment.java",
 609                                                                text);
 610     result.setContext(context);
 611     return result;
 612   }
 613
 614   @NotNull
 615   public PsiTypeCodeFragment createTypeCodeFragment(@NotNull String text, PsiElement context, boolean isPhysical) {
 616
 617     return createTypeCodeFragment(text, context, false, isPhysical, false);
 618   }
 619
 620
 621   @NotNull
 622   public PsiTypeCodeFragment createTypeCodeFragment(@NotNull String text,
 623                                                     PsiElement context,
 624                                                     boolean isVoidValid,
 625                                                     boolean isPhysical) {
 626     return createTypeCodeFragment(text, context, true, isPhysical, false);
 627   }
 628
 629   @NotNull
 630   public PsiTypeCodeFragment createTypeCodeFragment(@NotNull String text,
 631                                                     PsiElement context,
 632                                                     boolean isVoidValid,
 633                                                     boolean isPhysical,
 634                                                     boolean allowEllipsis) {
 635     final PsiTypeCodeFragmentImpl result = new PsiTypeCodeFragmentImpl(myManager.getProject(),
 636                                                                        isPhysical,
 637                                                                        allowEllipsis,
 638                                                                        "fragment.java",
 639                                                                        text);
 640     result.setContext(context);
 641     if (isVoidValid) {
 642       result.putUserData(PsiUtil.VALID_VOID_TYPE_IN_CODE_FRAGMENT, Boolean.TRUE);
 643     }
 644     return result;
 645   }
 646
 647
 648   @NotNull
 649   public PsiAnnotation createAnnotationFromText(@NotNull final String annotationText, final PsiElement context) throws IncorrectOperationException {
 650     final PsiAnnotation psiAnnotation = super.createAnnotationFromText(annotationText, context);
 651     markGenerated(psiAnnotation);
 652     return psiAnnotation;
 653   }
 654
 655   @NotNull
 656   public PsiCodeBlock createCodeBlockFromText(@NotNull final String text, final PsiElement context) throws IncorrectOperationException {
 657     final PsiCodeBlock psiCodeBlock = super.createCodeBlockFromText(text, context);
 658     markGenerated(psiCodeBlock);
 659     return psiCodeBlock;
 660   }
 661
 662   @NotNull
 663   public PsiEnumConstant createEnumConstantFromText(@NotNull final String text, final PsiElement context) throws IncorrectOperationException {
 664     final PsiEnumConstant enumConstant = super.createEnumConstantFromText(text, context);
 665     markGenerated(enumConstant);
 666     return enumConstant;
 667   }
 668
 669   @NotNull
 670   public PsiExpression createExpressionFromText(@NotNull final String text, final PsiElement context) throws IncorrectOperationException {
 671     final PsiExpression expression = super.createExpressionFromText(text, context);
 672     markGenerated(expression);
 673     return expression;
 674   }
 675
 676   @NotNull
 677   public PsiField createFieldFromText(@NotNull final String text, final PsiElement context) throws IncorrectOperationException {
 678     final PsiField psiField = super.createFieldFromText(text, context);
 679     markGenerated(psiField);
 680     return psiField;
 681   }
 682
 683   @NotNull
 684   public PsiParameter createParameterFromText(@NotNull final String text, final PsiElement context) throws IncorrectOperationException {
 685     final PsiParameter parameter = super.createParameterFromText(text, context);
 686     markGenerated(parameter);
 687     return parameter;
 688   }
 689
 690   @NotNull
 691   public PsiStatement createStatementFromText(@NotNull final String text, final PsiElement context) throws IncorrectOperationException {
 692     final PsiStatement statement = super.createStatementFromText(text, context);
 693     markGenerated(statement);
 694     return statement;
 695   }
 696
 697   @NotNull
 698   public PsiType createTypeFromText(@NotNull final String text, final PsiElement context) throws IncorrectOperationException {
 699     return createTypeInner(text, context, true);
 700   }
 701
 702   @NotNull
 703   public PsiTypeParameter createTypeParameterFromText(@NotNull final String text, final PsiElement context) throws
 704                                                                                                             IncorrectOperationException {
 705     final PsiTypeParameter typeParameter = super.createTypeParameterFromText(text, context);
 706     markGenerated(typeParameter);
 707     return typeParameter;
 708   }
 709
 710   @NotNull
 711   public PsiElement createWhiteSpaceFromText(@NotNull @NonNls final String text) throws IncorrectOperationException {
 712     final PsiElement whitespace = super.createWhiteSpaceFromText(text);
 713     markGenerated(whitespace);
 714     return whitespace;
 715   }
 716
 717   @NotNull
 718   public PsiMethod createMethodFromText(@NotNull final String text, final PsiElement context, final LanguageLevel level) throws
 719                                                                                                                          IncorrectOperationException {
 720     final PsiMethod method = super.createMethodFromText(text, context, level);
 721     markGenerated(method);
 722     return method;
 723   }
 724
 725
 726   @NotNull
 727   public PsiCatchSection createCatchSection(@NotNull final PsiClassType exceptionType,
 728                                             @NotNull final String exceptionName, final PsiElement context) throws
 729                                                                                                            IncorrectOperationException {
 730     final PsiCatchSection psiCatchSection = super.createCatchSection(exceptionType, exceptionName, context);
 731     markGenerated(psiCatchSection);
 732     return psiCatchSection;
 733   }
 734
 735   private static void markGenerated(final PsiElement element) {
 736     ((TreeElement)element.getNode()).acceptTree(new GeneratedMarkerVisitor());
 737   }
 738 }