public void TypeDefOrRef()
{
Assert.Equal(0, CodedIndex.TypeDefOrRef(default(TypeDefinitionHandle)));
Assert.Equal((0xffffff << 2) | 1, CodedIndex.TypeDefOrRef(MetadataTokens.TypeReferenceHandle(0xffffff)));
Assert.Equal(0x04 | 0, CodedIndex.TypeDefOrRef(MetadataTokens.TypeDefinitionHandle(1)));
Assert.Equal(0x04 | 1, CodedIndex.TypeDefOrRef(MetadataTokens.TypeReferenceHandle(1)));
}
public void Errors()
{
var badHandleKind = CustomAttributeHandle.FromRowId(1);
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.HasCustomAttribute(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.HasConstant(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.CustomAttributeType(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.HasDeclSecurity(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.HasFieldMarshal(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.HasSemantics(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.Implementation(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.MemberForwarded(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.MemberRefParent(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.MethodDefOrRef(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.ResolutionScope(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.TypeDefOrRef(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.TypeDefOrRefOrSpec(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.TypeOrMethodDef(badHandleKind));
AssertExtensions.Throws <ArgumentException>(null, () => CodedIndex.HasCustomDebugInformation(badHandleKind));
}
private void EncodeType(BlobBuilder blobBuilder, TypeDesc type)
{
if (type.IsPrimitive)
{
SignatureTypeCode primitiveCode;
switch (type.Category)
{
case TypeFlags.Void:
primitiveCode = SignatureTypeCode.Void;
break;
case TypeFlags.Boolean:
primitiveCode = SignatureTypeCode.Boolean;
break;
case TypeFlags.Char:
primitiveCode = SignatureTypeCode.Char;
break;
case TypeFlags.SByte:
primitiveCode = SignatureTypeCode.SByte;
break;
case TypeFlags.Byte:
primitiveCode = SignatureTypeCode.Byte;
break;
case TypeFlags.Int16:
primitiveCode = SignatureTypeCode.Int16;
break;
case TypeFlags.UInt16:
primitiveCode = SignatureTypeCode.UInt16;
break;
case TypeFlags.Int32:
primitiveCode = SignatureTypeCode.Int32;
break;
case TypeFlags.UInt32:
primitiveCode = SignatureTypeCode.UInt32;
break;
case TypeFlags.Int64:
primitiveCode = SignatureTypeCode.Int64;
break;
case TypeFlags.UInt64:
primitiveCode = SignatureTypeCode.UInt64;
break;
case TypeFlags.IntPtr:
primitiveCode = SignatureTypeCode.IntPtr;
break;
case TypeFlags.UIntPtr:
primitiveCode = SignatureTypeCode.UIntPtr;
break;
case TypeFlags.Single:
primitiveCode = SignatureTypeCode.Single;
break;
case TypeFlags.Double:
primitiveCode = SignatureTypeCode.Double;
break;
default:
throw new Exception("Unknown primitive type");
}
blobBuilder.WriteByte((byte)primitiveCode);
}
else if (type.IsSzArray)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.SZArray);
EncodeType(blobBuilder, type.GetParameterType());
}
else if (type.IsArray)
{
var arrayType = (ArrayType)type;
blobBuilder.WriteByte((byte)SignatureTypeCode.Array);
EncodeType(blobBuilder, type.GetParameterType());
var shapeEncoder = new ArrayShapeEncoder(blobBuilder);
// TODO Add support for non-standard array shapes
shapeEncoder.Shape(arrayType.Rank, default(ImmutableArray <int>), default(ImmutableArray <int>));
}
else if (type.IsPointer)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.Pointer);
EncodeType(blobBuilder, type.GetParameterType());
}
else if (type.IsFunctionPointer)
{
FunctionPointerType fnptrType = (FunctionPointerType)type;
EncodeMethodSignature(blobBuilder, fnptrType.Signature);
}
else if (type.IsByRef)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.ByReference);
EncodeType(blobBuilder, type.GetParameterType());
}
else if (type.IsObject)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.Object);
}
else if (type.IsString)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.String);
}
else if (type.IsWellKnownType(WellKnownType.TypedReference))
{
blobBuilder.WriteByte((byte)SignatureTypeCode.TypedReference);
}
else if (type.IsWellKnownType(WellKnownType.Void))
{
blobBuilder.WriteByte((byte)SignatureTypeCode.Void);
}
else if (type is SignatureVariable)
{
SignatureVariable sigVar = (SignatureVariable)type;
SignatureTypeCode code = sigVar.IsMethodSignatureVariable ? SignatureTypeCode.GenericMethodParameter : SignatureTypeCode.GenericTypeParameter;
blobBuilder.WriteByte((byte)code);
blobBuilder.WriteCompressedInteger(sigVar.Index);
}
else if (type is InstantiatedType)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.GenericTypeInstance);
EncodeType(blobBuilder, type.GetTypeDefinition());
blobBuilder.WriteCompressedInteger(type.Instantiation.Length);
foreach (var instantiationArg in type.Instantiation)
{
EncodeType(blobBuilder, instantiationArg);
}
}
else if (type is MetadataType)
{
var metadataType = (MetadataType)type;
// Must be class or valuetype
blobBuilder.WriteByte(type.IsValueType ? (byte)SignatureTypeKind.ValueType : (byte)SignatureTypeKind.Class);
int codedIndex = CodedIndex.TypeDefOrRef(GetTypeRef(metadataType));
blobBuilder.WriteCompressedInteger(codedIndex);
}
else
{
throw new Exception("Unexpected type");
}
}
