Java Code Examples for org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference#accept()

@Override
/* @Nullable */
protected LightweightTypeReference getBoundTypeArgument(ParameterizedTypeReference reference, JvmTypeParameter type, Set<JvmTypeParameter> visiting) {
	LightweightMergedBoundTypeArgument boundTypeArgument = getTypeParameterMapping().get(type);
	if (boundTypeArgument != null) {
		LightweightTypeReference boundReference = boundTypeArgument.getTypeReference();
		if (boundReference != null && reference != boundReference) {
			if (boundReference instanceof UnboundTypeReference)
				return boundReference.copyInto(getOwner());
			JvmType boundType = boundReference.getType();
			if (boundType != type) {
				if (visiting.add(type)) {
					try {
						LightweightTypeReference result = boundReference.accept(this, visiting);
						return result;
					} finally {
						visiting.remove(type);
					}
				} else {
					return reference;
				}
			} 
		}
	}
	return null;
}
 

protected void outerVisit(LightweightTypeReference declaredType, LightweightTypeReference actualType) {
	if (declaredType == actualType)
		return;
	String declaredKey = declaredType.getUniqueIdentifier();
	String actualKey = actualType.getUniqueIdentifier();
	if (!declaredKey.equals(actualKey)) {
		final String key = declaredKey + "//" + actualKey;
		if (recursionGuard.add(key)) {
			try {
				declaredType.accept(this, actualType);
			} finally {
				recursionGuard.remove(key);
			}
		}
	}
}
 

protected LightweightTypeReference assertIn(final LightweightTypeReference ref, final String expectation, final boolean isJava) {
  final TestAppender appender = new TestAppender(isJava);
  final LightweightTypeReferenceSerializer serializer = new LightweightTypeReferenceSerializer(appender);
  ref.accept(serializer);
  Assert.assertEquals(expectation, appender.toString());
  return ref;
}
 

@Override
public Boolean doVisitCompoundTypeReference(CompoundTypeReference reference, LightweightTraversalData data) {
	// TODO error message, cannot extend compound reference - error handling does not belong here
	boolean result = true;
	for(LightweightTypeReference component: reference.getMultiTypeComponents()) {
		Boolean componentsDone = component.accept(this, data);
		result &= componentsDone != null && componentsDone.booleanValue();
	}
	return result;
}
 

protected boolean visit(List<LightweightTypeReference> list) {
	for(LightweightTypeReference arg: list) {
		if (!arg.accept(this)) {
			return false;
		}
	}
	return true;
}
 

@Override
protected Boolean doVisitWildcardTypeReference(WildcardTypeReference reference) {
	if (reference.isResolved()) {
		return true;
	}
	if (!visit(reference.getUpperBounds())) {
		return false;
	}
	LightweightTypeReference lowerBound = reference.getLowerBound();
	if (lowerBound != null) {
		return lowerBound.accept(this);
	}
	return true;
}
 

protected LightweightTypeReference getBoundTypeArgument(ParameterizedTypeReference reference, JvmTypeParameter type,
		Visiting visiting) {
	LightweightMergedBoundTypeArgument boundTypeArgument = typeParameterMapping.get(type);
	if (boundTypeArgument != null) {
		LightweightTypeReference boundReference = boundTypeArgument.getTypeReference();
		if (boundReference != null && reference != boundReference && boundReference.getType() != type) {
			return boundReference.accept(this, visiting);
		}
	}
	return null;
}
 

@Override
protected LightweightTypeReference doVisitWildcardTypeReference(final WildcardTypeReference reference) {
  final LightweightTypeReference unknownType = this.visit(reference.getUpperBounds());
  if ((unknownType != null)) {
    return unknownType;
  }
  final LightweightTypeReference lowerBound = reference.getLowerBound();
  if ((lowerBound != null)) {
    return lowerBound.<LightweightTypeReference>accept(this);
  }
  return null;
}
 

@Override
public ITreeAppendable append(LightweightTypeReference typeRef) {
	typeRef.accept(lightweightTypeReferenceSerializer);
	return this;
}
 

public static LightweightTypeReference compute(LightweightTypeReference iterableOrArray, ITypeReferenceOwner owner) {
	LightweightTypeReference result = iterableOrArray.accept(new ElementOrComponentTypeComputer(owner));
	return result;
}
 

protected boolean isResolvedOrKnownTypeParam(LightweightTypeReference type) {
	return type.accept(new IsResolvedKnownTypeParamHelper());
}
 

@Override
protected void doVisitUnboundTypeReference(UnboundTypeReference reference, LightweightTypeReference param) {
	param.accept(unboundTypeReferenceTraverser, reference);
}
 

protected LightweightTypeReference visit(final List<LightweightTypeReference> references) {
  final Function1<LightweightTypeReference, LightweightTypeReference> _function = (LightweightTypeReference it) -> {
    return it.<LightweightTypeReference>accept(this);
  };
  return IterableExtensions.<LightweightTypeReference>head(IterableExtensions.<LightweightTypeReference>filterNull(ListExtensions.<LightweightTypeReference, LightweightTypeReference>map(references, _function)));
}
 

@Override
protected void doVisitWildcardTypeReference(WildcardTypeReference declaredReference, LightweightTypeReference param) {
	param.accept(wildcardTypeReferenceTraverser, declaredReference);
}
 

@Override
public IAppendable append(LightweightTypeReference typeRef) {
	typeRef.accept(lightweightTypeReferenceSerializer);
	return this;
}
 

protected LightweightTypeReference findUnknownType(final LightweightTypeReference type) {
  return type.<LightweightTypeReference>accept(this);
}
 

public LightweightTypeReference substitute(LightweightTypeReference original) {
	if (typeParameterMapping.isEmpty())
		return original;
	return original.accept(this, createVisiting());
}
 

@Override
public LightweightTypeReference substitute(final LightweightTypeReference original) {
  return original.<Set<JvmTypeParameter>, LightweightTypeReference>accept(this, CollectionLiterals.<JvmTypeParameter>newHashSet());
}
 

public Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> getTypeParameterMapping(LightweightTypeReference reference) {
	LightweightTraversalData data = new LightweightTraversalData();
	reference.accept(this, data);
	return data.getTypeParameterMapping();
}
 

public LightweightTypeReference withoutLocalTypes(LightweightTypeReference original) {
	return original.accept(this, VarianceInfo.OUT).typeReference;
}