Java Code Examples for org.eclipse.jdt.core.dom.IMethodBinding#getKey()

private SegmentSequence getSignatureAsSegmentSequence(IMethodBinding method) {
	String key = method.getKey();
	int start = key.indexOf('(');
	int end = key.lastIndexOf(')');
	SegmentSequence signaturex = SegmentSequence.create(";", key.substring(start + 1, end));
	return signaturex;
}
 

private static OverridableMethod convertToSerializableMethod(IMethodBinding binding, boolean unimplemented) {
	OverridableMethod result = new OverridableMethod();
	result.bindingKey = binding.getKey();
	result.name = binding.getName();
	result.parameters = getMethodParameterTypes(binding, false);
	result.unimplemented = unimplemented || Modifier.isAbstract(binding.getModifiers());
	result.declaringClass = binding.getDeclaringClass().getQualifiedName();
	result.declaringClassType = binding.getDeclaringClass().isInterface() ? "interface" : "class";
	return result;
}
 

/**
 * Returns a new {@link RemoteServiceProblem} for a
 * {@link RemoteServiceProblemType#MISSING_ASYNC_METHOD} on an
 * <b>asynchronous</b> type.
 */
static RemoteServiceProblem newMissingAsyncMethodOnAsync(
    IMethodBinding syncMethodBinding, TypeDeclaration asyncTypeDeclaration) {
  String[] messageArgs = {
      asyncTypeDeclaration.getName().getIdentifier(),
      toAsyncMethodSignature(syncMethodBinding)};
  String[] problemArgs = {"async", syncMethodBinding.getKey()};

  return RemoteServiceProblem.create(asyncTypeDeclaration.getName(),
      RemoteServiceProblemType.MISSING_ASYNC_METHOD, messageArgs, problemArgs);
}
 

/**
 * Returns a new {@link RemoteServiceProblem} for a
 * {@link RemoteServiceProblemType#MISSING_SYNC_METHOD} on a
 * <b>synchronous</b> type.
 */
static RemoteServiceProblem newMissingSyncMethodOnSync(
    TypeDeclaration syncTypeDeclaration, IMethodBinding asyncMethodBinding) {
  String[] messageArgs = {
      syncTypeDeclaration.getName().getIdentifier(),
      toSyncMethodSignature(asyncMethodBinding)};
  String[] problemArgs = {"sync", asyncMethodBinding.getKey()};

  return RemoteServiceProblem.create(syncTypeDeclaration.getName(),
      RemoteServiceProblemType.MISSING_SYNC_METHOD, messageArgs, problemArgs);
}
 

public ParameterTypeVariable2(TType type, int index, IMethodBinding binding) {
	super(type);
	Assert.isNotNull(binding);
	Assert.isTrue(0 <= index);
	fParameterIndex= index;
	fKey= binding.getKey();
}
 

public DeclaringTypeVariable makeDeclaringTypeVariable(IMethodBinding methodBinding) {
	String key= methodBinding.getKey();
	if (! fDeclaringTypeVariableMap.containsKey(key)){
		fDeclaringTypeVariableMap.put(key, new DeclaringTypeVariable(methodBinding));
		if (REPORT) nrCreated++;
	} else {
		if (REPORT) nrRetrieved++;
	}
	if (REPORT) dumpConstraintStats();
	return fDeclaringTypeVariableMap.get(key);
}
 

public ParameterTypeVariable makeParameterTypeVariable(IMethodBinding methodBinding,
													   int parameterIndex) {
	String key= methodBinding.getKey() + parameterIndex;
	if (! fParameterMap.containsKey(key)){
		fParameterMap.put(key, new ParameterTypeVariable(methodBinding, parameterIndex));
		if (REPORT) nrCreated++;
	} else {
		if (REPORT) nrRetrieved++;
	}
	if (REPORT) dumpConstraintStats();
	return fParameterMap.get(key);
}
 

public ReturnTypeVariable makeReturnTypeVariable(IMethodBinding methodBinding) {
	String key= methodBinding.getKey();
	if (!fReturnVariableMap.containsKey(key)){
		fReturnVariableMap.put(key, new ReturnTypeVariable(methodBinding));
		if (REPORT) nrCreated++;
	} else {
		if (REPORT) nrRetrieved++;
	}
	if (REPORT) dumpConstraintStats();
	return fReturnVariableMap.get(key);
}
 

public LspMethodBinding(IMethodBinding binding) {
	this.bindingKey = binding.getKey();
	this.name = binding.getName();
	this.parameters = Stream.of(binding.getParameterTypes()).map(type -> type.getName()).toArray(String[]::new);
}
 

public ReturnTypeVariable2(TType type, IMethodBinding binding) {
	super(type);
	fKey= binding.getKey();
}