Class LexicalPreservingPrinter

java.lang.Object
com.github.javaparser.printer.lexicalpreservation.LexicalPreservingPrinter
public class LexicalPreservingPrinter extends Object
The LexicalPreservingPrinter is responsible for maintaining the original formatting and layout of Java source code when the Abstract Syntax Tree (AST) is modified. This printer works by: 1. Storing the original textual representation alongside the AST nodes 2. Tracking changes made to the AST through a sophisticated change tracking system 3. Applying only the necessary modifications while preserving unchanged portions 4. Maintaining original spacing, comments, and formatting wherever possible The lexical preservation is essential for code refactoring tools that need to modify code while maintaining its original style and readability. Usage Pattern: 1. Setup lexical preservation on a CompilationUnit before making changes 2. Modify the AST as needed 3. Use this printer to generate the modified source code with preserved formatting

  • Field Details

    • JAVA_UTIL_OPTIONAL

      private static String JAVA_UTIL_OPTIONAL

    • JAVAPARSER_AST_NODELIST

      private static String JAVAPARSER_AST_NODELIST

    • observer

      private static AstObserver observer
      Observer tracks changes made to AST nodes. The observer is responsible for detecting modifications to specific types of nodes and updating the lexical preservation data accordingly.

    • NODE_TEXT_DATA

      public static final DataKey<NodeText> NODE_TEXT_DATA
      The nodetext for a node is stored in the node's data field. This is the key to set and retrieve it.

    • LEXICAL_DIFFERENCE_CALCULATOR

      private static final LexicalDifferenceCalculator LEXICAL_DIFFERENCE_CALCULATOR

  • Constructor Details

    • LexicalPreservingPrinter

      public LexicalPreservingPrinter()

  • Method Details

    • setup

      public static <N extends Node> N setup(N node)
      Initializes lexical preservation for the given CompilationUnit. This method must be called before making any modifications to the AST if you want to preserve the original formatting. The setup process involves: 1. Parsing the original source code into tokens 2. Creating NodeText representations for each AST node 3. Establishing relationships between tokens and nodes 4. Setting up change observers to track future modifications
      Parameters:
      cu - The CompilationUnit to setup for lexical preservation
      Returns:
      The same CompilationUnit with lexical preservation enabled

    • isAvailableOn

      public static boolean isAvailableOn(Node node)

    • createObserver

      private static AstObserver createObserver()

    • storeInitialText

      private static void storeInitialText(Node root)
      Stores the initial textual representation for all nodes in the AST. This method creates a NodeText object for each node that captures: - The original tokens associated with the node - Whitespace and formatting information - Comment associations - Token positions and relationships This initial storage is crucial for later determining what has changed and what should be preserved during printing.
      Parameters:
      cu - The root node to process

    • storeInitialTextForOneNode

      private static void storeInitialTextForOneNode(Node node, List<JavaToken> nodeTokens)
      Recursively stores initial text representation for all child nodes of the given parent node. This method ensures that every node in the AST has its original textual representation captured for lexical preservation.
      Parameters:
      node - The parent node whose children should be processed

    • tokensPreceeding

      private static Iterator<TokenTextElement> tokensPreceeding(Node node)

    • print

      public static String print(Node node)
      Prints the given node to a string while preserving the original formatting where possible and applying changes where the AST has been modified. This method analyzes the changes made to the AST since lexical preservation was setup and generates output that: - Preserves original formatting for unchanged portions - Applies appropriate formatting for new or modified content - Maintains consistency with the original code style
      Parameters:
      node - The node to print (typically a CompilationUnit)
      Returns:
      A string representation of the node with preserved formatting

    • prettyPrintingTextNode

      private static void prettyPrintingTextNode(Node node, NodeText nodeText)

    • interpret

      private static NodeText interpret(Node node, CsmElement csm, NodeText nodeText)
      TODO: Process CsmIndent and CsmUnindent before reaching this point

    • getOrCreateNodeText

      static NodeText getOrCreateNodeText(Node node)

    • findIndentation

      static List<TextElement> findIndentation(Node node)

    • isReturningOptionalNodeList

      private static boolean isReturningOptionalNodeList(Method m)

    • findNodeListName

      private static ObservableProperty findNodeListName(NodeList<?> nodeList)