Fix IFIleElementType Generation in Main

src/org/intellij/grammar/Main.java

@@ -9,8 +9,8 @@
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.impl.DebugUtil;
+import org.intellij.grammar.fleet.FleetBnfAttributePostprocessor;
 import org.intellij.grammar.generator.ParserGenerator;
-import org.intellij.grammar.fleet.FleetBnfFileWrapper;
 import org.intellij.grammar.fleet.FleetFileTypeGenerator;
 import org.intellij.grammar.psi.BnfFile;
 
@@ -127,7 +127,7 @@ public static void main(String[] args) {
           for (File file : files) {
             if (file.isDirectory() || !grammarPattern.matcher(file.getName()).matches()) continue;
             PsiFile psiFile = LightPsi.parseFile(file, parserDefinition);
-            if (!(psiFile instanceof BnfFile)) continue;
+            if (!(psiFile instanceof BnfFile bnfFile)) continue;
 
             // for light-psi-all building:
             if (args[0].contains("lightpsi")) {
@@ -139,7 +139,9 @@ public static void main(String[] args) {
             }
             count++;
 
-            BnfFile bnfFile = (generateForFleet) ? FleetBnfFileWrapper.wrapBnfFile((BnfFile)psiFile) : (BnfFile)psiFile;
+            if (generateForFleet) {
+              FleetBnfAttributePostprocessor.prepareForFleetGeneration(bnfFile);
+            }
             new ParserGenerator(bnfFile, grammarDir.getAbsolutePath(), output.getAbsolutePath(), "").generate();
             if (generateFileTypeElement) {
               new FleetFileTypeGenerator((BnfFile)psiFile,

src/org/intellij/grammar/fleet/FleetBnfAttributePostprocessor.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2011-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+ */
+
+package org.intellij.grammar.fleet;
+
+import com.intellij.openapi.util.Key;
+import org.intellij.grammar.KnownAttribute;
+import org.intellij.grammar.generator.IAttributePostProcessor;
+import org.intellij.grammar.psi.BnfFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+
+import static org.intellij.grammar.KnownAttribute.*;
+import static org.intellij.grammar.fleet.FleetConstants.*;
+
+//Wraps BnfFile to produce fleet-related attribute values.
+//Implemented as BnfFileImpl extension to avoid implementation of all methods in BnfFile interface
+public class FleetBnfAttributePostprocessor implements IAttributePostProcessor {
+
+  public static final Key<Boolean> GENERATE_FOR_FLEET = Key.create("GENERATE_FOR_FLEET");
+
+  private final Map<String, String> myFleetAttributeValuesSubstitution = Map.of(
+    PARSER_UTIL_CLASS.getName(), GPUB_CLASS,
+    ELEMENT_TYPE_CLASS.getName(), IELEMENTTYPE_CLASS,
+    TOKEN_TYPE_CLASS.getName(), IELEMENTTYPE_CLASS
+  );
+
+  private final Map<String, String> myDefaultGeneratedNames = Map.of(
+    PARSER_CLASS.getName(), PARSER_CLASS_DEFAULT,
+    ELEMENT_TYPE_HOLDER_CLASS.getName(), ELEMENT_TYPE_HOLDER_DEFAULT
+  );
+
+  private final List<String> mySuppressedFactories = List.of(ELEMENT_TYPE_FACTORY.getName(),
+                                                                    TOKEN_TYPE_FACTORY.getName());
+
+  @Override
+  public <T> @Nullable T postProcessValue(@NotNull KnownAttribute<T> knownAttribute, @Nullable T value) {
+    return findAttributeValue(value, knownAttribute);
+  }
+
+  public static BnfFile prepareForFleetGeneration(@NotNull BnfFile bnfFile) {
+    bnfFile.putUserData(GENERATE_FOR_FLEET, true);
+    bnfFile.putUserData(ATTRIBUTE_POSTPROCESSOR, new FleetBnfAttributePostprocessor());
+    return bnfFile;
+  }
+
+  private <T> T findAttributeValue(@Nullable T value,
+                                         @NotNull KnownAttribute<T> knownAttribute) {
+    //Bypass adjustment logic for the GENERATE attribute
+    if (knownAttribute.getName().equals(GENERATE.getName())) {
+      return value;
+    }
+
+    if (myFleetAttributeValuesSubstitution.containsKey(knownAttribute.getName())) {
+      if (!knownAttribute.getDefaultValue().equals(value)) {
+        return adjustedValue(value);
+      }
+      else {
+        return (T)myFleetAttributeValuesSubstitution.get(knownAttribute.getName());
+      }
+    }
+
+    ////If a generated element name has been requested, return value adjusted accordingly
+    if (myDefaultGeneratedNames.containsKey(knownAttribute.getName())) {
+      return adjustedValue(value);
+    }
+
+    //If a factory attribute is requested, return null to force generation of non-factory methods
+    if (mySuppressedFactories.contains(knownAttribute.getName())) {
+      return null;
+    }
+
+    return value;
+  }
+
+  private static <T> T adjustedValue(@Nullable T origin) {
+    if (origin instanceof String && !((String)origin).startsWith(FLEET_NAMESPACE_PREFIX)) {
+      return (T)(FLEET_NAMESPACE_PREFIX + origin);
+    }
+    return origin;
+  }
+}

src/org/intellij/grammar/fleet/GenerateFleetAction.java

@@ -17,6 +17,6 @@ public class GenerateFleetAction extends GenerateAction {
   protected @Nullable PsiFile getBnfFile(VirtualFile file, PsiManager psiManager) {
     var psiFile = super.getBnfFile(file, psiManager);
     if (psiFile == null) return null;
-    return FleetBnfFileWrapper.wrapBnfFile((BnfFile)psiFile);
+    return FleetBnfAttributePostprocessor.prepareForFleetGeneration((BnfFile)psiFile);
   }
 }

src/org/intellij/grammar/generator/GenOptions.java

@@ -6,7 +6,7 @@
 
 import com.intellij.openapi.util.text.StringUtil;
 import org.intellij.grammar.KnownAttribute;
-import org.intellij.grammar.fleet.FleetBnfFileWrapper;
+import org.intellij.grammar.fleet.FleetBnfAttributePostprocessor;
 import org.intellij.grammar.psi.BnfFile;
 
 import java.util.Map;
@@ -38,7 +38,7 @@ public class GenOptions {
   public final int javaVersion;
 
   public GenOptions(BnfFile myFile) {
-    var generateForFleet = myFile instanceof FleetBnfFileWrapper;
+    var generateForFleet = Boolean.TRUE.equals(myFile.getUserData(FleetBnfAttributePostprocessor.GENERATE_FOR_FLEET));
     Map<String, String> genOptions = getRootAttribute(myFile, KnownAttribute.GENERATE).asMap();
     names = Names.forName(genOptions.get("names"));
     generatePsi = getGenerateOption(myFile, KnownAttribute.GENERATE_PSI, genOptions, "psi") && !generateForFleet;

src/org/intellij/grammar/generator/GeneratorBase.java

@@ -9,7 +9,7 @@
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.containers.JBIterable;
 import org.intellij.grammar.KnownAttribute;
-import org.intellij.grammar.fleet.FleetBnfFileWrapper;
+import org.intellij.grammar.fleet.FleetBnfAttributePostprocessor;
 import org.intellij.grammar.psi.BnfFile;
 import org.intellij.grammar.psi.BnfRule;
 import org.jetbrains.annotations.NotNull;
@@ -58,7 +58,7 @@ protected GeneratorBase(@NotNull BnfFile psiFile,
                           @NotNull String outputPath,
                           @NotNull String packagePrefix) {
     myFile = psiFile;
-    myGenerateForFleet = psiFile instanceof FleetBnfFileWrapper;
+    myGenerateForFleet = psiFile.getUserData(FleetBnfAttributePostprocessor.GENERATE_FOR_FLEET);
 
     G = new GenOptions(psiFile);
     mySourcePath = sourcePath;

src/org/intellij/grammar/generator/IAttributePostProcessor.java

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2011-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+ */
+
+package org.intellij.grammar.generator;
+
+import com.intellij.openapi.util.Key;
+import org.intellij.grammar.KnownAttribute;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public interface IAttributePostProcessor {
+  Key<IAttributePostProcessor> ATTRIBUTE_POSTPROCESSOR = Key.create("ATTRIBUTE_POSTPROCESSOR");
+
+  @Nullable
+  default <T> T postProcessValue(@NotNull KnownAttribute<T> knownAttribute, @Nullable T value) {
+    return null;
+  }
+}

src/org/intellij/grammar/generator/IntelliJPlatformConstants.java

@@ -4,7 +4,7 @@
 
 package org.intellij.grammar.generator;
 
-import org.intellij.grammar.fleet.FleetBnfFileWrapper;
+import org.intellij.grammar.fleet.FleetBnfAttributePostprocessor;
 import org.intellij.grammar.fleet.FleetConstants;
 import org.intellij.grammar.psi.BnfFile;
 
@@ -52,6 +52,6 @@ private IntelliJPlatformConstants(String builder,
                                   FleetConstants.TOKEN_SET_CLASS);
 
   public static IntelliJPlatformConstants getConstantSetForBnf(BnfFile file) {
-    return (file instanceof FleetBnfFileWrapper) ? FleetConstantSet : IdeaConstantSet;
+    return (Boolean.TRUE.equals(file.getUserData(FleetBnfAttributePostprocessor.GENERATE_FOR_FLEET))) ? FleetConstantSet : IdeaConstantSet;
   }
 }

src/org/intellij/grammar/generator/ParserGenerator.java

@@ -1511,7 +1511,7 @@ private void generateElementTypesHolder(String className, Map<String, BnfRule> s
     out("}");
   }
 
-  protected boolean useFactory(String factory) {
+  protected static boolean useFactory(String factory) {
     return factory != null;
   }
 

src/org/intellij/grammar/psi/impl/BnfFileImpl.java

@@ -6,17 +6,15 @@
 
 import com.intellij.extapi.psi.PsiFileBase;
 import com.intellij.openapi.fileTypes.FileType;
-import com.intellij.openapi.util.AtomicClearableLazyValue;
-import com.intellij.openapi.util.ClearableLazyValue;
-import com.intellij.openapi.util.Conditions;
-import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.util.*;
 import com.intellij.psi.FileViewProvider;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.JBIterable;
 import org.intellij.grammar.BnfFileType;
 import org.intellij.grammar.BnfLanguage;
 import org.intellij.grammar.KnownAttribute;
+import org.intellij.grammar.generator.IAttributePostProcessor;
 import org.intellij.grammar.generator.ParserGeneratorUtil;
 import org.intellij.grammar.psi.*;
 import org.jetbrains.annotations.NotNull;
@@ -32,7 +30,7 @@
  * Time: 23:55
  */
 public class BnfFileImpl extends PsiFileBase implements BnfFile {
-  
+
   private final ClearableLazyValue<Map<String, BnfRule>> myRules = lazyValue(this::calcRules);
   private final ClearableLazyValue<List<BnfAttrs>> myGlobalAttributes = lazyValue(this::calcAttributes);
   private final ClearableLazyValue<Map<String, List<AttributeInfo>>> myAttributeValues = lazyValue(this::calcAttributeValues);
@@ -73,6 +71,12 @@
 
   @Override
   public <T> T findAttributeValue(@Nullable BnfRule rule, @NotNull KnownAttribute<T> knownAttribute, @Nullable String match) {
+    var postProcessor = getUserData(IAttributePostProcessor.ATTRIBUTE_POSTPROCESSOR);
+    if (postProcessor == null) return findAttributeValueInner(rule, knownAttribute, match);
+    else return postProcessor.postProcessValue(knownAttribute, findAttributeValueInner(rule, knownAttribute, match));
+  }
+
+  private  <T> T findAttributeValueInner(@Nullable BnfRule rule, @NotNull KnownAttribute<T> knownAttribute, @Nullable String match) {
     T combined = null;
     boolean copied = false;
     for (AttributeInfo info : getMatchingAttributes(rule, knownAttribute, match)) {
@@ -191,10 +195,6 @@
     return result;
   }
 
-  protected boolean hasAttributeValue(@Nullable BnfRule rule, @NotNull KnownAttribute<?> attribute, @Nullable String match) {
-    return getMatchingAttributes(rule, attribute, match).isNotEmpty();
-  }
-
   protected static @NotNull <T> AtomicClearableLazyValue<T> lazyValue(Supplier<T> producer) {
     return new AtomicClearableLazyValue<>() {
       @Override