Java LiteralTree.getValue方法代码示例

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
@Override
public Description matchMethodInvocation(MethodInvocationTree t, VisitorState state) {
  if (PRECONDITIONS_CHECK.matches(t, state)
      && t.getArguments().size() >= 2
      && t.getArguments().get(1) instanceof LiteralTree) {
    LiteralTree formatStringTree = (LiteralTree) t.getArguments().get(1);
    if (formatStringTree.getValue() instanceof String) {
      String formatString = (String) formatStringTree.getValue();
      int expectedArgs = expectedArguments(formatString);
      if (expectedArgs < t.getArguments().size() - 2
          && BAD_PLACEHOLDER_REGEX.matcher(formatString).find()) {
        return describe(t, state);
      }
    }
  }
  return Description.NO_MATCH;
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
private Description matchDivZero(Tree tree, ExpressionTree operand, VisitorState state) {
  if (!anyOf(kindIs(Kind.DIVIDE), kindIs(Kind.DIVIDE_ASSIGNMENT)).matches(tree, state)) {
    return Description.NO_MATCH;
  }

  if (!kindIs(Kind.INT_LITERAL).matches(operand, state)) {
    return Description.NO_MATCH;
  }

  LiteralTree rightOperand = (LiteralTree) operand;
  if (((Integer) rightOperand.getValue()) != 0) {
    return Description.NO_MATCH;
  }

  // Find and replace enclosing Statement.
  StatementTree enclosingStmt =
      ASTHelpers.findEnclosingNode(state.getPath(), StatementTree.class);
  return (enclosingStmt != null)
      ? describeMatch(
          tree,
          SuggestedFix.replace(enclosingStmt, "throw new ArithmeticException(\"/ by zero\");"))
      : describeMatch(tree);
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private Description matchDivZero(Tree tree, ExpressionTree operand, VisitorState state) {
  if (!anyOf(kindIs(Kind.DIVIDE), kindIs(Kind.DIVIDE_ASSIGNMENT)).matches(tree, state)) {
    return Description.NO_MATCH;
  }

  if (!kindIs(Kind.INT_LITERAL).matches(operand, state)) {
    return Description.NO_MATCH;
  }

  LiteralTree rightOperand = (LiteralTree) operand;
  if (((Integer) rightOperand.getValue()) != 0) {
    return Description.NO_MATCH;
  }

  // Find and replace enclosing Statement.
  StatementTree enclosingStmt =
      ASTHelpers.findEnclosingNode(state.getPath(), StatementTree.class);
  SuggestedFix fix = new SuggestedFix();
  if (enclosingStmt != null) {
    fix = fix.replace(enclosingStmt, "throw new ArithmeticException(\"/ by zero\");");
  }

  return describeMatch(tree, fix);
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
@Override
public Void visitLiteral(LiteralTree tree, AnnotatedTypeMirror type) {
    if (!type.isAnnotatedInHierarchy(FORMAT)) {
        String format = null;
        if (tree.getKind() == Tree.Kind.STRING_LITERAL) {
            format = (String) tree.getValue();
        } else if (tree.getKind() == Tree.Kind.CHAR_LITERAL) {
            format = Character.toString((Character) tree.getValue());
        }
        if (format != null) {
            AnnotationMirror anno;
            try {
                ConversionCategory[] cs = FormatUtil.formatParameterCategories(format);
                anno = FormatterAnnotatedTypeFactory.this.treeUtil.categoriesToFormatAnnotation(cs);
            } catch (IllegalFormatException e) {
                anno = FormatterAnnotatedTypeFactory.this.treeUtil.exceptionToInvalidFormatAnnotation(e);
            }
            type.addAnnotation(anno);
        }
    }
    return super.visitLiteral(tree, type);
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
/**
 * Case 1: valid regular expression String or char literal.
 * Adds PartialRegex annotation to String literals that are not valid
 * regular expressions.
 */
@Override
public Void visitLiteral(LiteralTree tree, AnnotatedTypeMirror type) {
    if (!type.isAnnotatedInHierarchy(REGEX)) {
        String regex = null;
        if (tree.getKind() == Tree.Kind.STRING_LITERAL) {
            regex = (String) tree.getValue();
        } else if (tree.getKind() == Tree.Kind.CHAR_LITERAL) {
            regex = Character.toString((Character) tree.getValue());
        }
        if (regex != null) {
            if (isRegex(regex)) {
                int groupCount = getGroupCount(regex);
                type.addAnnotation(createRegexAnnotation(groupCount));
            } else {
                type.addAnnotation(createPartialRegexAnnotation(regex));
            }
        }
    }
    return super.visitLiteral(tree, type);
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
/**
 * Go through the string patterns and add the greatest lower bound of all matching patterns.
 */
@Override
public Void visitLiteral(LiteralTree tree, AnnotatedTypeMirror type) {
    if (!stringPatterns.isEmpty() && tree.getKind() == Tree.Kind.STRING_LITERAL) {
        Set<? extends AnnotationMirror> res = null;
        String string = (String) tree.getValue();
        for (Pattern pattern : stringPatterns.keySet()) {
            if (pattern.matcher(string).matches()) {
                if (res == null) {
                    res = stringPatterns.get(pattern);
                } else {
                    Set<? extends AnnotationMirror> newres = stringPatterns.get(pattern);
                    res = qualHierarchy.greatestLowerBounds(res, newres);
                }
            }
        }
        if (res != null) {
            type.addAnnotations(res);
        }
    }
    return super.visitLiteral(tree, type);
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
public Boolean visitLiteral(LiteralTree node, TreePath p) {
    if (p == null)
        return super.visitLiteral(node, p);

    LiteralTree lt = (LiteralTree) p.getLeaf();
    Object nodeValue = node.getValue();
    Object ltValue = lt.getValue();

    if (nodeValue == ltValue)
        return true;

    if (nodeValue == null || ltValue == null)
        return false;
    return nodeValue.equals(ltValue);
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
@Override
public Number visitLiteral(LiteralTree node, Void p) {
    if (node.getValue() instanceof Number) {
        return (Number) node.getValue();
    }

    return super.visitLiteral(node, p);
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
@Override
public Object visitLiteral(LiteralTree node, Void p) {
    if (node.getKind() == NULL_LITERAL) {
        return enhanceProcessing ? NULL : null;
    } 
    return node.getValue();
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
@Override
public Boolean visitLiteral(LiteralTree node, ConstructorData p) {
    Object val = node.getValue();

    if (val instanceof Boolean) {
        return (Boolean) val;
    } else {
        return null;
    }
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
@Override
public String visitLiteral(LiteralTree node, Void p) {
    if (node.getValue() instanceof String)
        return "...";

    int start = (int) info.getTrees().getSourcePositions().getStartPosition(info.getCompilationUnit(), node);
    int end   = (int) info.getTrees().getSourcePositions().getEndPosition(info.getCompilationUnit(), node);

    if (start < 0 || end < 0 || end < start) {
        return node.toString();
    }
    
    return info.getText().substring(start, end);
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
private boolean canBooleanExpressionEvalToTrue(ExpressionTree expressionTree) {
  if (expressionTree instanceof LiteralTree) {
    LiteralTree expressionAsLiteral = (LiteralTree) expressionTree;
    if (expressionAsLiteral.getValue() instanceof Boolean) {
      return (boolean) expressionAsLiteral.getValue();
    } else {
      throw new RuntimeException("not a boolean expression!");
    }
  }
  // We are fairly conservative, anything other than 'return false;' is assumed to potentially be
  // true.
  // No SAT-solving or any other funny business.
  return true;
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
@Override
public boolean matches(ExpressionTree expressionTree, VisitorState state) {
  if (expressionTree instanceof LiteralTree) {
    LiteralTree literalTree = (LiteralTree) expressionTree;
    Object actualValue = literalTree.getValue();
    return actualValue instanceof String && pattern.matcher((String) actualValue).matches();
  } else {
    return false;
  }
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
@Override
public Description matchLiteral(LiteralTree tree, VisitorState state) {
  Object value = tree.getValue();
  if (!(value instanceof String)) {
    return NO_MATCH;
  }
  if (!missingFormatArgs((String) value)) {
    return NO_MATCH;
  }
  Tree parent = state.getPath().getParentPath().getLeaf();
  if (!MATCHER.matches(parent, state)) {
    return NO_MATCH;
  }
  return describeMatch(tree);
}
 

import com.sun.source.tree.LiteralTree; //导入方法依赖的package包/类
@Override
public boolean matches(ExpressionTree expressionTree, VisitorState state) {
  if (expressionTree instanceof LiteralTree) {
    LiteralTree literalTree = (LiteralTree) expressionTree;
    Object actualValue = literalTree.getValue();
    return actualValue instanceof String && actualValue.equals(value);
  } else {
    return false;
  }
}