/// <inheritdoc />
public bool Equals(TypeSignature x, TypeSignature y)
{
if (ReferenceEquals(x, y))
{
return(true);
}
if (ReferenceEquals(x, null) || ReferenceEquals(y, null))
{
return(false);
}
return(x switch
{
CorLibTypeSignature corLibType => Equals(corLibType, y as CorLibTypeSignature),
TypeDefOrRefSignature typeDefOrRef => Equals(typeDefOrRef, y as TypeDefOrRefSignature),
SzArrayTypeSignature szArrayType => Equals(szArrayType, y as SzArrayTypeSignature),
ArrayTypeSignature arrayType => Equals(arrayType, y as ArrayTypeSignature),
ByReferenceTypeSignature byRefType => Equals(byRefType, y as ByReferenceTypeSignature),
BoxedTypeSignature boxedType => Equals(boxedType, y as BoxedTypeSignature),
GenericInstanceTypeSignature genericInstanceType => Equals(genericInstanceType, y as GenericInstanceTypeSignature),
GenericParameterSignature genericParameter => Equals(genericParameter, y as GenericParameterSignature),
PointerTypeSignature pointerType => Equals(pointerType, y as PointerTypeSignature),
PinnedTypeSignature pinnedType => Equals(pinnedType, y as PinnedTypeSignature),
CustomModifierTypeSignature modifierType => Equals(modifierType, y as CustomModifierTypeSignature),
_ => throw new NotSupportedException()
});
public void CreateArrayField()
{
// set up temp assembly.
var assembly = Utilities.CreateTempNetAssembly();
var typeSystem = assembly.NetDirectory.MetadataHeader.TypeSystem;
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var fieldTable = tableStream.GetTable <FieldDefinition>();
var importer = new ReferenceImporter(tableStream);
// create field.
var arraySignature = new ArrayTypeSignature(typeSystem.Int32);
arraySignature.Dimensions.Add(new ArrayDimension(2, 1));
arraySignature.Dimensions.Add(new ArrayDimension(2));
arraySignature.Dimensions.Add(new ArrayDimension());
var field = new FieldDefinition(FieldName, FieldAttributes.Public | FieldAttributes.Static,
new FieldSignature(importer.ImportTypeSignature(arraySignature)));
fieldTable.Add(field);
// build and validate.
assembly = Utilities.RebuildNetAssembly(assembly);
fieldTable = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>().GetTable <FieldDefinition>();
field = fieldTable.First(x => x.Name == FieldName);
Assert.IsInstanceOfType(field.Signature.FieldType, typeof(ArrayTypeSignature));
Utilities.ValidateType(arraySignature, field.Signature.FieldType);
}
/// <inheritdoc />
public object VisitArrayType(ArrayTypeSignature signature)
{
signature.BaseType.AcceptVisitor(this);
_writer.Write('[');
for (int i = 0; i < signature.Dimensions.Count; i++)
{
_writer.Write(',');
}
_writer.Write(']');
return(null);
}
public void MultidimensionalArray()
{
const string ns = "MyNamespace";
const string name = "MyType";
var elementType = new TypeReference(_module, ns, name).ToTypeSignature();
var expected = new ArrayTypeSignature(elementType, 4);
var actual = TypeNameParser.Parse(_module, $"{ns}.{name}[,,,]");
Assert.Equal(expected, actual, _comparer);
}
private ArrayTypeSignature ImportArrayTypeSignature(Type arrayType)
{
var newSignature = new ArrayTypeSignature(ImportTypeSignature(arrayType.GetElementType()))
{
IsValueType = arrayType.IsValueType
};
for (int i = 0; i < arrayType.GetArrayRank(); i++)
{
newSignature.Dimensions.Add(new ArrayDimension());
}
return(newSignature);
}
/// <inheritdoc />
public int GetHashCode(ArrayTypeSignature obj)
{
unchecked
{
int hashCode = (int)obj.ElementType << ElementTypeOffset;
hashCode = (hashCode * 397) ^ GetHashCode(obj.BaseType);
for (int i = 0; i < obj.Dimensions.Count; i++)
{
hashCode = (hashCode * 397) ^ obj.Dimensions[i].GetHashCode();
}
return(hashCode);
}
}
public void ArrayType(GenericParameterType parameterType, int index)
{
// 0![0..10]
var genericParameter = new GenericParameterSignature(parameterType, index);
var signature = new ArrayTypeSignature(genericParameter)
{
Dimensions = { new ArrayDimension(10, 0) }
};
Assert.Equal(new ArrayTypeSignature(GetTypeArguments(parameterType)[index])
{
Dimensions = { new ArrayDimension(10, 0) }
}, signature.InstantiateGenericTypes(_context), Comparer);
}
/// <summary>
/// Determines whether two types are considered equal according to their signature.
/// </summary>
/// <param name="signature1">The first type to compare.</param>
/// <param name="signature2">The second type to compare.</param>
/// <returns><c>True</c> if the types are considered equal, <c>False</c> otherwise.</returns>
public bool Equals(ArrayTypeSignature signature1, ArrayTypeSignature signature2)
{
if (signature1 == null && signature2 == null)
{
return(true);
}
if (signature1 == null || signature2 == null)
{
return(false);
}
return(Equals(signature1.BaseType, signature2.BaseType) &&
signature1.Dimensions.Count == signature2.Dimensions.Count &&
signature1.Dimensions.Where((d, i) => Equals(d, signature2.Dimensions[i])).Count() == signature1.Dimensions.Count);
}
private void IdentifyAndMakeSerializableRecursively(ITypeSignature type, MessageLocation location)
{
switch (type.TypeSignatureElementKind)
{
case TypeSignatureElementKind.Intrinsic:
// This works automatically for most, but:
// Consider an error for object, IntPtr, but also consider that those fields may be marked as [NonSerialized].
// In the future, we might want to exclude such fields.
break;
case TypeSignatureElementKind.TypeDef:
TypeDefDeclaration typeDef = (TypeDefDeclaration)type;
if (typeDef.DeclaringAssembly == this.Project.Module.DeclaringAssembly)
{
MakeSerializableRecursively(typeDef);
}
else
{
VerifySerializable(typeDef, location);
}
break;
case TypeSignatureElementKind.TypeRef:
IdentifyAndMakeSerializableRecursively(type.GetTypeDefinition(), location);
break;
case TypeSignatureElementKind.GenericInstance:
GenericTypeInstanceTypeSignature
genericInstanceSignature = type as GenericTypeInstanceTypeSignature;
IdentifyAndMakeSerializableRecursively(genericInstanceSignature.ElementType, location);
foreach (ITypeSignature argument in genericInstanceSignature.GenericArguments)
{
IdentifyAndMakeSerializableRecursively(argument, location);
}
break;
case TypeSignatureElementKind.Array:
ArrayTypeSignature arraySignature = type as ArrayTypeSignature;
IdentifyAndMakeSerializableRecursively(arraySignature.ElementType, location);
break;
default:
// Other possible signature types can be ignored:
// Pointers: they cannot be serialized
// Custom modifiers: they should not be used on fields.
break;
}
}
public void ImportArrayType()
{
var baseType = CreateTypeDefOrRef(typeof(Form));
var arrayType = new ArrayTypeSignature(baseType);
arrayType.Dimensions.Add(new ArrayDimension(null, 0));
arrayType.Dimensions.Add(new ArrayDimension(null, 1));
var newType = TestTypeSpecification(arrayType, baseType.Type);
Assert.AreEqual(arrayType.Dimensions.Count, newType.Dimensions.Count);
for (int i = 0; i < arrayType.Dimensions.Count; i++)
{
Assert.AreEqual(arrayType.Dimensions[i].Size, newType.Dimensions[i].Size);
Assert.AreEqual(arrayType.Dimensions[i].LowerBound, newType.Dimensions[i].LowerBound);
}
}
public void MatchArrayTypeSignatures()
{
var arrayType1 = new ArrayTypeSignature(CreateTypeSig1());
arrayType1.Dimensions.Add(new ArrayDimension(null, 0));
arrayType1.Dimensions.Add(new ArrayDimension(null, 0));
var arrayType2 = new ArrayTypeSignature(CreateTypeSig1());
arrayType2.Dimensions.Add(new ArrayDimension(null, 0));
arrayType2.Dimensions.Add(new ArrayDimension(null, 0));
var arrayType3 = new ArrayTypeSignature(CreateTypeSig1());
arrayType3.Dimensions.Add(new ArrayDimension(null, 0));
arrayType3.Dimensions.Add(new ArrayDimension(null, 1));
VerifyMatching(arrayType1, arrayType2, arrayType3);
}
private TypeSignature ParseType()
{
TypeSignature type = ParseTypeName();
while (true)
{
switch (CurrentToken.Kind)
{
case TokenKind.OpenBracket:
EatToken();
int rank = 1;
while (CurrentToken.Kind == TokenKind.Comma)
{
EatToken();
rank++;
}
if (CurrentToken.Kind != TokenKind.CloseBracket)
{
throw InvalidSignature();
}
EatToken();
type = new ArrayTypeSignature(type, rank);
break;
case TokenKind.Asterisk:
EatToken();
type = new PointerTypeSignature(type);
break;
case TokenKind.QuestionMark:
EatToken();
type = new GenericTypeSignature(
SpecialType.System_Nullable_T.GetTypeSignature(),
ImmutableArray.Create(type)
);
break;
default:
return(type);
}
}
}
/// <inheritdoc />
public bool Equals(ArrayTypeSignature x, ArrayTypeSignature y)
{
if (ReferenceEquals(x, y))
{
return(true);
}
if (x is null || y is null || x.Dimensions.Count != y.Dimensions.Count)
{
return(false);
}
for (int i = 0; i < x.Dimensions.Count; i++)
{
if (x.Dimensions[i].Size != y.Dimensions[i].Size ||
x.Dimensions[i].LowerBound != y.Dimensions[i].LowerBound)
{
return(false);
}
}
return(Equals(x.BaseType, y.BaseType));
}
private ArrayTypeSignature ImportArrayTypeSignature(ArrayTypeSignature signature)
{
var newSignature = new ArrayTypeSignature(ImportTypeSignature(signature.BaseType))
{
IsValueType = signature.IsValueType
};
foreach (var dimension in signature.Dimensions)
{
var newDimension = new ArrayDimension();
if (dimension.Size.HasValue)
{
newDimension.Size = dimension.Size.Value;
}
if (dimension.LowerBound.HasValue)
{
newDimension.LowerBound = dimension.LowerBound.Value;
}
newSignature.Dimensions.Add(newDimension);
}
return(newSignature);
}
private TypeSignature ParseArrayTypeSpec(TypeSignature typeName)
{
var dimensions = new List <ArrayDimension>
{
ParseArrayDimension()
};
bool stop = false;
while (!stop)
{
var nextToken = Expect(TypeNameTerminal.CloseBracket, TypeNameTerminal.Comma);
switch (nextToken.Terminal)
{
case TypeNameTerminal.CloseBracket:
stop = true;
break;
case TypeNameTerminal.Comma:
dimensions.Add(ParseArrayDimension());
break;
}
}
if (dimensions.Count == 1 && dimensions[0].Size == null && dimensions[0].LowerBound == null)
{
return(new SzArrayTypeSignature(typeName));
}
var result = new ArrayTypeSignature(typeName);
foreach (var dimension in dimensions)
{
result.Dimensions.Add(dimension);
}
return(result);
}
/// <inheritdoc /> public TypeMemoryLayout VisitArrayType(ArrayTypeSignature signature) => new TypeMemoryLayout(signature, PointerSize);
public uint VisitArrayType(ArrayTypeSignature signature) => PointerSize;
