Java ASTResolving.getRelaxingTypes方法代码示例

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private Type evaluateVariableType(
    AST ast,
    ImportRewrite imports,
    ImportRewriteContext importRewriteContext,
    IBinding targetContext) {
  if (fOriginalNode.getParent() instanceof MethodInvocation) {
    MethodInvocation parent = (MethodInvocation) fOriginalNode.getParent();
    if (parent.getExpression() == fOriginalNode) {
      // _x_.foo() -> guess qualifier type by looking for a type with method 'foo'
      ITypeBinding[] bindings =
          ASTResolving.getQualifierGuess(
              fOriginalNode.getRoot(),
              parent.getName().getIdentifier(),
              parent.arguments(),
              targetContext);
      if (bindings.length > 0) {
        for (int i = 0; i < bindings.length; i++) {
          addLinkedPositionProposal(KEY_TYPE, bindings[i]);
        }
        return imports.addImport(bindings[0], ast, importRewriteContext);
      }
    }
  }

  ITypeBinding binding = ASTResolving.guessBindingForReference(fOriginalNode);
  if (binding != null) {
    if (binding.isWildcardType()) {
      binding = ASTResolving.normalizeWildcardType(binding, isVariableAssigned(), ast);
      if (binding == null) {
        // only null binding applies
        binding = ast.resolveWellKnownType("java.lang.Object"); // $NON-NLS-1$
      }
    }

    if (isVariableAssigned()) {
      ITypeBinding[] typeProposals = ASTResolving.getRelaxingTypes(ast, binding);
      for (int i = 0; i < typeProposals.length; i++) {
        addLinkedPositionProposal(KEY_TYPE, typeProposals[i]);
      }
    }
    return imports.addImport(binding, ast, importRewriteContext);
  }
  // no binding, find type AST node instead -> ABC a= x-> use 'ABC' as is
  Type type = ASTResolving.guessTypeForReference(ast, fOriginalNode);
  if (type != null) {
    return type;
  }
  if (fVariableKind == CONST_FIELD) {
    return ast.newSimpleType(ast.newSimpleName("String")); // $NON-NLS-1$
  }
  return ast.newSimpleType(ast.newSimpleName("Object")); // $NON-NLS-1$
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private Type evaluateType(AST ast) {
  ITypeBinding[] proposals = ASTResolving.getRelaxingTypes(ast, fTypeBinding);
  for (int i = 0; i < proposals.length; i++) {
    addLinkedPositionProposal(KEY_TYPE, proposals[i]);
  }
  ImportRewrite importRewrite = getImportRewrite();
  CompilationUnit cuNode = (CompilationUnit) fNodeToAssign.getRoot();
  ImportRewriteContext context =
      new ContextSensitiveImportRewriteContext(
          cuNode, fNodeToAssign.getStartPosition(), importRewrite);
  return importRewrite.addImport(fTypeBinding, ast, context);
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private Type evaluateParameterType(
    AST ast, Expression elem, String key, ImportRewriteContext context) {
  ITypeBinding binding = Bindings.normalizeTypeBinding(elem.resolveTypeBinding());
  if (binding != null && binding.isWildcardType()) {
    binding = ASTResolving.normalizeWildcardType(binding, true, ast);
  }
  if (binding != null) {
    ITypeBinding[] typeProposals = ASTResolving.getRelaxingTypes(ast, binding);
    for (int i = 0; i < typeProposals.length; i++) {
      addLinkedPositionProposal(key, typeProposals[i]);
    }
    return getImportRewrite().addImport(binding, ast, context);
  }
  return ast.newSimpleType(ast.newSimpleName("Object")); // $NON-NLS-1$
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private Type evaluateType(AST ast) {
	ITypeBinding[] proposals= ASTResolving.getRelaxingTypes(ast, fTypeBinding);
	for (int i= 0; i < proposals.length; i++) {
		addLinkedPositionProposal(KEY_TYPE, proposals[i]);
	}
	ImportRewrite importRewrite= getImportRewrite();
	CompilationUnit cuNode= (CompilationUnit) fNodeToAssign.getRoot();
	ImportRewriteContext context= new ContextSensitiveImportRewriteContext(cuNode, fNodeToAssign.getStartPosition(), importRewrite);
	return importRewrite.addImport(fTypeBinding, ast, context);
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private Type evaluateParameterType(AST ast, Expression elem, String key, ImportRewriteContext context) {
	ITypeBinding binding= Bindings.normalizeTypeBinding(elem.resolveTypeBinding());
	if (binding != null && binding.isWildcardType()) {
		binding= ASTResolving.normalizeWildcardType(binding, true, ast);
	}
	if (binding != null) {
		ITypeBinding[] typeProposals= ASTResolving.getRelaxingTypes(ast, binding);
		for (int i= 0; i < typeProposals.length; i++) {
			addLinkedPositionProposal(key, typeProposals[i]);
		}
		return getImportRewrite().addImport(binding, ast, context);
	}
	return ast.newSimpleType(ast.newSimpleName("Object")); //$NON-NLS-1$
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private void fixupNames(ASTRewrite rewrite, ArrayList<String> usedNames) {
  AST ast = rewrite.getAST();
  // set names for new parameters
  for (int i = 0; i < fParameterChanges.length; i++) {
    ChangeDescription curr = fParameterChanges[i];
    if (curr instanceof ModifyDescription) {
      ModifyDescription desc = (ModifyDescription) curr;

      String typeKey = getParamTypeGroupId(i);
      String nameKey = getParamNameGroupId(i);

      // collect name suggestions
      String favourite = null;
      String[] excludedNames = usedNames.toArray(new String[usedNames.size()]);

      String suggestedName = desc.name;
      if (suggestedName != null) {
        favourite =
            StubUtility.suggestArgumentName(
                getCompilationUnit().getJavaProject(), suggestedName, excludedNames);
        addLinkedPositionProposal(nameKey, favourite, null);
      }

      if (desc instanceof EditDescription) {
        addLinkedPositionProposal(nameKey, ((EditDescription) desc).orginalName, null);
      }

      Type type = desc.resultingParamType;
      String[] suggestedNames =
          StubUtility.getArgumentNameSuggestions(
              getCompilationUnit().getJavaProject(), type, excludedNames);
      for (int k = 0; k < suggestedNames.length; k++) {
        addLinkedPositionProposal(nameKey, suggestedNames[k], null);
      }
      if (favourite == null) {
        favourite = suggestedNames[0];
      }
      usedNames.add(favourite);

      SimpleName[] names = desc.resultingParamName;
      for (int j = 0; j < names.length; j++) {
        names[j].setIdentifier(favourite);
        addLinkedPosition(rewrite.track(names[j]), false, nameKey);
      }

      addLinkedPosition(rewrite.track(desc.resultingParamType), true, typeKey);

      // collect type suggestions
      ITypeBinding[] bindings = ASTResolving.getRelaxingTypes(ast, desc.type);
      for (int k = 0; k < bindings.length; k++) {
        addLinkedPositionProposal(typeKey, bindings[k]);
      }

      SimpleName tagArg = desc.resultingTagArg;
      if (tagArg != null) {
        tagArg.setIdentifier(favourite);
        addLinkedPosition(rewrite.track(tagArg), false, nameKey);
      }
    }
  }
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private Type evaluateVariableType(AST ast, ImportRewrite imports, ImportRewriteContext importRewriteContext, IBinding targetContext) {
	if (fOriginalNode.getParent() instanceof MethodInvocation) {
		MethodInvocation parent= (MethodInvocation) fOriginalNode.getParent();
		if (parent.getExpression() == fOriginalNode) {
			// _x_.foo() -> guess qualifier type by looking for a type with method 'foo'
			ITypeBinding[] bindings= ASTResolving.getQualifierGuess(fOriginalNode.getRoot(), parent.getName().getIdentifier(), parent.arguments(), targetContext);
			if (bindings.length > 0) {
				for (int i= 0; i < bindings.length; i++) {
					addLinkedPositionProposal(KEY_TYPE, bindings[i]);
				}
				return imports.addImport(bindings[0], ast, importRewriteContext);
			}
		}
	}

	ITypeBinding binding= ASTResolving.guessBindingForReference(fOriginalNode);
	if (binding != null) {
		if (binding.isWildcardType()) {
			binding= ASTResolving.normalizeWildcardType(binding, isVariableAssigned(), ast);
			if (binding == null) {
				// only null binding applies
				binding= ast.resolveWellKnownType("java.lang.Object"); //$NON-NLS-1$
			}
		}

		if (isVariableAssigned()) {
			ITypeBinding[] typeProposals= ASTResolving.getRelaxingTypes(ast, binding);
			for (int i= 0; i < typeProposals.length; i++) {
				addLinkedPositionProposal(KEY_TYPE, typeProposals[i]);
			}
		}
		return imports.addImport(binding, ast, importRewriteContext);
	}
	// no binding, find type AST node instead -> ABC a= x-> use 'ABC' as is
	Type type= ASTResolving.guessTypeForReference(ast, fOriginalNode);
	if (type != null) {
		return type;
	}
	if (fVariableKind == CONST_FIELD) {
		return ast.newSimpleType(ast.newSimpleName("String")); //$NON-NLS-1$
	}
	return ast.newSimpleType(ast.newSimpleName("Object")); //$NON-NLS-1$
}
 

import org.eclipse.jdt.internal.ui.text.correction.ASTResolving; //导入方法依赖的package包/类
private void fixupNames(ASTRewrite rewrite, ArrayList<String> usedNames) {
	AST ast= rewrite.getAST();
	// set names for new parameters
	for (int i= 0; i < fParameterChanges.length; i++) {
		ChangeDescription curr= fParameterChanges[i];
		if (curr instanceof ModifyDescription) {
			ModifyDescription desc= (ModifyDescription) curr;

			String typeKey= getParamTypeGroupId(i);
			String nameKey= getParamNameGroupId(i);

			// collect name suggestions
			String favourite= null;
			String[] excludedNames= usedNames.toArray(new String[usedNames.size()]);

			String suggestedName= desc.name;
			if (suggestedName != null) {
				favourite= StubUtility.suggestArgumentName(getCompilationUnit().getJavaProject(), suggestedName, excludedNames);
				addLinkedPositionProposal(nameKey, favourite, null);
			}

			if (desc instanceof EditDescription) {
				addLinkedPositionProposal(nameKey, ((EditDescription)desc).orginalName, null);
			}

			Type type= desc.resultingParamType;
			String[] suggestedNames= StubUtility.getArgumentNameSuggestions(getCompilationUnit().getJavaProject(), type, excludedNames);
			for (int k= 0; k < suggestedNames.length; k++) {
				addLinkedPositionProposal(nameKey, suggestedNames[k], null);
			}
			if (favourite == null) {
				favourite= suggestedNames[0];
			}
			usedNames.add(favourite);

			SimpleName[] names= desc.resultingParamName;
			for (int j= 0; j < names.length; j++) {
				names[j].setIdentifier(favourite);
				addLinkedPosition(rewrite.track(names[j]), false, nameKey);
			}

			addLinkedPosition(rewrite.track(desc.resultingParamType), true, typeKey);

			// collect type suggestions
			ITypeBinding[] bindings= ASTResolving.getRelaxingTypes(ast, desc.type);
			for (int k= 0; k < bindings.length; k++) {
				addLinkedPositionProposal(typeKey, bindings[k]);
			}

			SimpleName tagArg= desc.resultingTagArg;
			if (tagArg != null) {
				tagArg.setIdentifier(favourite);
				addLinkedPosition(rewrite.track(tagArg), false, nameKey);
			}
		}
	}
}