@Override
protected String getMangledNameWithGenerics(boolean convertArrays) {
StringBuilder builder = new StringBuilder("_L");
// to distinguish generics that have the same type name, we have to add packages as well
for (ModifiedType modifiedType : types) {
Type type = modifiedType.getType();
if (type
instanceof
TypeParameter) // always print _T to avoid problems with CanEqual<T> and CanEqual<V>
builder.append("_T");
else if (type instanceof ArrayType) // only convert the first layer
{
if (convertArrays)
builder.append(((ArrayType) type).convertToGeneric().getMangledNameWithGenerics(false));
else builder.append(type.getMangledNameWithGenerics(true));
} else builder.append(type.getMangledNameWithGenerics(true));
// Type type = modifiedType.getType();
// shadow.typecheck.Package _package = type.getPackage();
// builder.append(type.getPackage().getMangledName() + type.getMangledNameWithGenerics());
}
builder.append("_R");
return builder.toString();
}
public void setNodeType(SimpleNode node) {
if (types.size() == 1) {
ModifiedType modifiedType = types.get(0);
node.setType(modifiedType.getType());
if (modifiedType.getModifiers().isNullable()) node.addModifier(Modifiers.NULLABLE);
if (modifiedType.getModifiers().isReadonly()) node.addModifier(Modifiers.READONLY);
if (modifiedType.getModifiers().isImmutable()) node.addModifier(Modifiers.IMMUTABLE);
} else node.setType(this);
}
@Override
public SequenceType partiallyReplace(List<ModifiedType> values, List<ModifiedType> replacements) {
SequenceType temp = new SequenceType();
for (int i = 0; i < types.size(); i++) {
ModifiedType type = types.get(i);
if (type != null) {
SimpleModifiedType dummy =
new SimpleModifiedType(
type.getType().partiallyReplace(values, replacements), type.getModifiers());
temp.add(dummy);
} else temp.add(null);
}
return temp;
}
public String toString(String begin, String end, int options) {
StringBuilder builder = new StringBuilder(begin);
boolean first = true;
for (ModifiedType type : types) {
if (first) first = false;
else builder.append(",");
if (type != null) {
builder.append(type.getModifiers().toString());
builder.append(type.getType().toString(options));
}
}
builder.append(end);
return builder.toString();
}
public boolean canAccept(
ModifiedType inputType, SubstitutionKind substitutionType, List<TypeCheckException> errors) {
if (substitutionType.equals(SubstitutionKind.BINDING)) {
SequenceType input = new SequenceType();
input.add(inputType);
return canAccept(input, substitutionType, errors);
} else {
if (inputType.getType() instanceof SequenceType)
return canAccept((SequenceType) inputType.getType(), substitutionType, errors);
// for splats
for (ModifiedType modifiedType : types) {
if (!BaseChecker.checkAssignment(
modifiedType, inputType, AssignmentType.EQUAL, substitutionType, errors)) return false;
}
return true;
}
}
public Modifiers getModifiers(int i) {
ModifiedType modifiedType = types.get(i);
return modifiedType == null ? null : modifiedType.getModifiers();
}
public Type getType(int i) {
ModifiedType modifiedType = types.get(i);
return modifiedType == null ? null : modifiedType.getType();
}
