Package com.vaadin.copilot.javarewriter

Class JavaRewriterUtil

java.lang.Object
com.vaadin.copilot.javarewriter.JavaRewriterUtil
public class JavaRewriterUtil extends Object
Util methods for rewriting Java

  • Method Details

    • fromExpression

      public static Object fromExpression(com.github.javaparser.ast.expr.Expression arg, com.github.javaparser.resolution.types.ResolvedType expectedType)
      Parses the given expression and returns the object it represents.

      If the argument is a null literal, it is returned as is. Method call expressions are also returned as is.

      Parameters:
      arg - the expression to parse
      expectedType - the expected type of the object or null if unknown
      Returns:
      the object represented by the expression

    • findMethodCallStatements

      public static List<com.github.javaparser.ast.expr.MethodCallExpr> findMethodCallStatements(JavaRewriter.ComponentInfo componentDefinition)

    • findMethodCallNonStatements

      public static List<com.github.javaparser.ast.expr.MethodCallExpr> findMethodCallNonStatements(JavaRewriter.ComponentInfo componentDefinition)

    • findParameterUsage

      public static List<com.github.javaparser.ast.expr.Expression> findParameterUsage(JavaRewriter.ComponentInfo componentDefinition)

    • extractInlineVariableToLocalVariable

      public static JavaRewriter.ExtractInlineVariableResult extractInlineVariableToLocalVariable(JavaRewriter.ComponentInfo componentInfo)
      Extracts an inline variable to local variable with a new variable name.
      Parameters:
      componentInfo - Component info
      Returns:
      Block, new variable name and index, null if attach call is not found.

    • inlineAssignment

      public static boolean inlineAssignment(JavaRewriter.ComponentInfo componentInfo)

    • hasSingleParameterMethod

      public static boolean hasSingleParameterMethod(Class<? extends Component> type, String func)
      Checks if the given component type has a method with the given name, taking one parameter.
      Parameters:
      type - The component type
      func - The method name
      Returns:
      true if the method exists, false otherwise

    • findBlockStatementIndex

      public static int findBlockStatementIndex(com.github.javaparser.ast.Node node)
      Finds the index of the statement that wraps the given node in the closest block statement.
      Parameters:
      node - The node to find the wrapping statement for
      Returns:
      The index of the statement in the block statement

    • findFreeVariableName

      public static String findFreeVariableName(JavaRewriter.ComponentInfo componentInfo, com.github.javaparser.ast.stmt.BlockStmt block)
      Finds a free variable name based on the component type.
      Parameters:
      componentInfo - The component info
      block - The block the variable will be used in
      Returns:
      A free variable name

    • findFreeVariableName

      public static String findFreeVariableName(String base, com.github.javaparser.ast.stmt.BlockStmt block)
      Finds a free variable name based on the given base name.
      Parameters:
      base - The base name
      block - The block the variable will be used in
      Returns:
      A free variable name

    • removeStatement

      public static void removeStatement(com.github.javaparser.ast.Node node)
      Removes the statement that wraps the given node.
      Parameters:
      node - the node to remove

    • removeFromStringConcatenation

      public static boolean removeFromStringConcatenation(com.github.javaparser.ast.Node node)
      Removes the given node from a string concatenation expression.
      Parameters:
      node - the node to remove
      Returns:
      true if the node was removed, false otherwise

    • findReference

      public static Optional<com.github.javaparser.ast.expr.Expression> findReference(com.github.javaparser.ast.NodeList<com.github.javaparser.ast.expr.Expression> nodes, JavaRewriter.ComponentInfo componentDefinition)
      Finds a node among the nodes which refer to the given component.
      Parameters:
      nodes - the nodes to search
      componentDefinition - the component definition
      Returns:
      the first node that refers to the component, if any

    • findFieldDeclaration

      public static com.github.javaparser.ast.body.FieldDeclaration findFieldDeclaration(com.github.javaparser.ast.Node nodeInClass, String fieldName)
      Finds the field declaration for the given field name in the class of the given node.
      Parameters:
      nodeInClass - the node in the class
      fieldName - the field name
      Returns:
      the field declaration
      Throws:
      IllegalArgumentException - if the field is not found

    • onSameLine

      public static boolean onSameLine(com.github.javaparser.ast.Node node1, com.github.javaparser.ast.Node node2)
      Checks if the two nodes are on the same line.
      Parameters:
      node1 - the first node
      node2 - the second node
      Returns:
      true if the nodes are on the same line, false otherwise

    • getSetterAndValue

      public static JavaRewriter.SetterAndValue getSetterAndValue(Class<?> componentType, String property, Object value)
      Gets the setter name and value for the given component type, property and value.
      Parameters:
      componentType - the component type
      property - the property
      value - the value
      Returns:
      the setter name and value

    • getSetterName

      public static String getSetterName(String property, Class<?> type, boolean includeReactConversions)
      Gets the setter name for the given property.
      Parameters:
      property - the property
      type - the component type
      includeReactConversions - whether to include React property name conversions in the setter name
      Returns:
      the setter name

    • getFieldOrVariableName

      public static String getFieldOrVariableName(JavaRewriter.ComponentInfo componentInfo)
      Gets the field or local variable name for the given component.
      Parameters:
      componentInfo - the component info
      Returns:
      the field or local variable name

    • addImport

      public static void addImport(com.github.javaparser.ast.CompilationUnit compilationUnit, String qualifiedName)
      Adds an import to the given compilation unit if it is not already imported.
      Parameters:
      compilationUnit - the compilation unit
      qualifiedName - the qualified name of the import

    • getJavaIdentifier

      public static String getJavaIdentifier(String str)
      Converts the given string into a valid Java identifier.
      Parameters:
      str - the string
      Returns:
      the Java identifier

    • hasMethod

      public static boolean hasMethod(Class<?> type, String methodName)
      Checks if the given component type has the given method.
      Parameters:
      type - the component type
      methodName - the method to check for
      Returns:
      true if the component has the method, false otherwise

    • getClass

      public static Class<?> getClass(String name) throws IllegalArgumentException
      Finds the class for the given source type.
      Parameters:
      name - the class name
      Returns:
      the class for the given name
      Throws:
      IllegalArgumentException - if the class is not found

    • removeArgumentCalls

      public static void removeArgumentCalls(List<com.github.javaparser.ast.expr.MethodCallExpr> methods, List<? extends com.github.javaparser.ast.expr.Expression> argumentsToRemove, boolean removeMethodIfNoArgs)

    • removeArgumentCalls

      public static boolean removeArgumentCalls(com.github.javaparser.ast.expr.MethodCallExpr methodCallExpr, List<? extends com.github.javaparser.ast.expr.Expression> argumentsToRemove, boolean removeMethodIfNoArgs)

    • findLocationBefore

      public static JavaRewriter.InsertionPoint findLocationBefore(com.github.javaparser.ast.expr.Expression expr)

    • findLocationAfter

      public static JavaRewriter.InsertionPoint findLocationAfter(com.github.javaparser.ast.expr.Expression expr)

    • findLocationAtEnd

      public static JavaRewriter.InsertionPoint findLocationAtEnd(com.github.javaparser.ast.stmt.Statement statement)

    • addFieldAfter

      public static void addFieldAfter(com.github.javaparser.ast.body.FieldDeclaration newField, com.github.javaparser.ast.body.FieldDeclaration reference)

    • clone

      public static <T extends com.github.javaparser.ast.Node> T clone(T node)

    • getAttachArgument

      public static Optional<com.github.javaparser.ast.expr.Expression> getAttachArgument(JavaRewriter.ComponentInfo component)

    • getAttachArgumentOrThrow

      public static com.github.javaparser.ast.expr.Expression getAttachArgumentOrThrow(JavaRewriter.ComponentInfo component)

    • setNameExprScope

      public static boolean setNameExprScope(com.github.javaparser.ast.expr.MethodCallExpr newCall, com.github.javaparser.ast.expr.NameExpr nameExpr)
      Sets the name expression scope for the given method call. For a simple call like `foo.setBar()` this changes `foo` and for nested calls like `foo.baz().fo().a().b()` it also changes `foo`.
      Parameters:
      newCall - the method call to change
      nameExpr - the new scope
      Returns:
      true if the scope was changed, false otherwise

    • typesEqual

      public static boolean typesEqual(com.github.javaparser.resolution.types.ResolvedType javaParserType, Class<?> javaReflectionType)
      Checks if the given type is equal to the given reflection type.
      Parameters:
      javaParserType - the Java parser type
      javaReflectionType - the Java reflection type
      Returns:
      true if the types are equal, false otherwise

    • isArrayArgument

      public static boolean isArrayArgument(String className, String methodName, int argumentIndex)
      Uses reflection API for finding class name, method and the argument to find whether argument is array.
      Parameters:
      className - full class name of a class.
      methodName - method name
      argumentIndex - argument to look up. It can exceed the method parameters, in that case the last argument is taken into account
      Returns:
      true if argument is an array, false otherwise