Package org.sonar.python.tree

Class TreeUtils

java.lang.Object
org.sonar.python.tree.TreeUtils
public class TreeUtils extends Object

  • Method Details

    • firstAncestor

      @CheckForNull public static Tree firstAncestor(Tree tree, Predicate<Tree> predicate)

    • firstAncestorOfKind

      @CheckForNull public static Tree firstAncestorOfKind(Tree tree, Tree.Kind... kinds)

    • firstAncestorOfClass

      @CheckForNull public static <T extends Tree> T firstAncestorOfClass(Tree tree, Class<T> clazz)

    • groupAssignmentByParentStatementList

      public static Collector<Tree,?,Map<Tree,Tree>> groupAssignmentByParentStatementList()

    • getTreeByPositionComparator

      public static Comparator<Tree> getTreeByPositionComparator()

    • tokens

      public static List<Token> tokens(Tree tree)

    • nonWhitespaceTokens

      public static List<Token> nonWhitespaceTokens(Tree tree)

    • hasDescendant

      public static boolean hasDescendant(Tree tree, Predicate<Tree> predicate)

    • flattenTuples

      public static Stream<Expression> flattenTuples(Expression expression)

    • getSymbolFromTree

      public static Optional<Symbol> getSymbolFromTree(@Nullable Tree tree)

    • getClassSymbolFromDef

      @CheckForNull public static ClassSymbol getClassSymbolFromDef(@Nullable ClassDef classDef)

    • getEnclosingClassDef

      @CheckForNull public static ClassDef getEnclosingClassDef(Tree tree)

    • getParentClassesFQN

      public static List<String> getParentClassesFQN(ClassDef classDef)

    • getFunctionSymbolFromDef

      @CheckForNull public static FunctionSymbol getFunctionSymbolFromDef(@Nullable FunctionDef functionDef)

    • nonTupleParameters

      public static List<Parameter> nonTupleParameters(FunctionDef functionDef)

    • positionalParameters

      public static List<Parameter> positionalParameters(FunctionDef functionDef)

    • topLevelFunctionDefs

      public static List<FunctionDef> topLevelFunctionDefs(ClassDef classDef)
      Collects all top-level function definitions within a class def. It is used to discover methods defined within "strange" constructs, such as class A: if p: def f(self): ...

    • findIndentationSize

      public static int findIndentationSize(Tree tree)

    • argumentByKeyword

      @CheckForNull public static RegularArgument argumentByKeyword(String keyword, List<Argument> arguments)

    • nthArgumentOrKeyword

      @CheckForNull public static RegularArgument nthArgumentOrKeyword(int argPosition, String keyword, List<Argument> arguments)

    • nthArgumentOrKeywordOptional

      public static Optional<RegularArgument> nthArgumentOrKeywordOptional(int argPosition, String keyword, List<Argument> arguments)

    • isBooleanLiteral

      public static boolean isBooleanLiteral(Tree tree)

    • nameFromExpression

      public static String nameFromExpression(Expression expression)

    • nameFromQualifiedOrCallExpression

      public static Optional<String> nameFromQualifiedOrCallExpression(Expression expression)

    • nameFromExpressionOrQualifiedExpression

      public static Optional<String> nameFromExpressionOrQualifiedExpression(Expression expression)

    • nameFromQualifiedExpression

      public static String nameFromQualifiedExpression(QualifiedExpression qualifiedExpression)

    • decoratorNameFromExpression

      @CheckForNull public static String decoratorNameFromExpression(Expression expression)

    • asyncTokenOfEnclosingFunction

      public static Optional<Token> asyncTokenOfEnclosingFunction(Tree tree)

    • isFunctionWithGivenDecoratorFQN

      public static boolean isFunctionWithGivenDecoratorFQN(Tree tree, String decoratorFQN)

    • isDecoratorWithFQN

      public static boolean isDecoratorWithFQN(Decorator decorator, String fullyQualifiedName)

    • fullyQualifiedNameFromQualifiedExpression

      public static Optional<String> fullyQualifiedNameFromQualifiedExpression(QualifiedExpression qualifiedExpression)

    • fullyQualifiedNameFromExpression

      public static Optional<String> fullyQualifiedNameFromExpression(Expression expression)

    • locationInFile

      @CheckForNull public static LocationInFile locationInFile(Tree tree, @Nullable String fileId)

    • getTreeSeparatorOrLastToken

      public static Token getTreeSeparatorOrLastToken(Tree tree)
      Statements can have a separator like semicolon. When handling ranges we want to take them into account.

    • toInstanceOfMapper

      public static <T extends Tree> Function<Tree,T> toInstanceOfMapper(Class<T> castToClass)

    • toOptionalInstanceOfMapper

      public static <T extends Tree> Function<Tree,Optional<T>> toOptionalInstanceOfMapper(Class<T> castToClass)

    • toOptionalInstanceOf

      public static <T extends Tree> Optional<T> toOptionalInstanceOf(Class<T> castToClass, @Nullable Tree tree)

    • toStreamInstanceOfMapper

      public static <T extends Tree> Function<Tree,Stream<T>> toStreamInstanceOfMapper(Class<T> castToClass)

    • firstChild

      public static Optional<Tree> firstChild(Tree tree, Predicate<Tree> filter)

    • treeToString

      public static String treeToString(Tree tree, boolean renderMultiline)

    • dottedNameToPartFqn

      public static List<String> dottedNameToPartFqn(DottedName dottedName)

    • stringValueFromNameOrQualifiedExpression

      public static Optional<String> stringValueFromNameOrQualifiedExpression(Expression expression)
      Extracts the string value from a name or qualified expression. Returns empty Optional for expressions that are not simple names or chains of qualified expressions.

    • inferSingleAssignedExpressionType

      public static PythonType inferSingleAssignedExpressionType(Expression expr)

      This method returns the type of an expression.

      If the expression is a name, the function will find where the name was assigned and return the type of the assigned expression. If the expression is a qualified expression, it will resolve the type of the qualifier and then resolve the member type on that type. The function will do that recursively until it finds a name or resolves something to an PythonType.UNKNOWN type. If the expression is neither a name nor a qualified expression, it will return Expression.typeV2().

      This function is intended to used with variables that are defined in the global scope, and then used in a function. Since type inference does not propagate types from global scope to function scope, this would leave the name of the variable in the function without a type.

      See SONARPY-3218 and SONARPY-3219 for more details.

      Parameters:
      name - the name of a variable that is assigned in the global scope
      Returns:
      the type of the name, or `UNKNOWN` if it cannot be determined

    • getLocalVariableSymbols

      public static Set<SymbolV2> getLocalVariableSymbols(FunctionDef functionDef)

    • isDoubleStarExpression

      public static boolean isDoubleStarExpression(Tree tree)
      Checks if a tree node represents a double-star (**) expression. Supports both Parameter (e.g. **kwargs in function definitions) and UnpackingExpression (e.g. **kwargs in call arguments).

    • isConstantName

      public static boolean isConstantName(String name)