public void FieldModifiers()
{
var text =
@"
class A
{
internal protected const long N1 = 0;
public volatile byte N2 = 0;
private static char N3 = ' ';
}
";
var comp = CreateEmptyCompilation(text);
var global = comp.GlobalNamespace;
var a = global.GetTypeMembers("A", 0).Single();
var n1 = a.GetMembers("N1").Single() as FieldSymbol;
Assert.True(n1.IsConst);
Assert.False(n1.IsVolatile);
Assert.True(n1.IsStatic);
Assert.Equal(0, n1.TypeWithAnnotations.CustomModifiers.Length);
var n2 = a.GetMembers("N2").Single() as FieldSymbol;
Assert.False(n2.IsConst);
Assert.True(n2.IsVolatile);
Assert.False(n2.IsStatic);
Assert.Equal(1, n2.TypeWithAnnotations.CustomModifiers.Length);
CustomModifier mod = n2.TypeWithAnnotations.CustomModifiers[0];
Assert.False(mod.IsOptional);
Assert.Equal("System.Runtime.CompilerServices.IsVolatile[missing]", mod.Modifier.ToTestDisplayString());
var n3 = a.GetMembers("N3").Single() as FieldSymbol;
Assert.False(n3.IsConst);
Assert.False(n3.IsVolatile);
Assert.True(n3.IsStatic);
Assert.Equal(0, n3.TypeWithAnnotations.CustomModifiers.Length);
}
private static bool CustomModifiersMatch(ImmutableArray <CustomModifier> candidateCustomModifiers, ImmutableArray <ModifierInfo <TypeSymbol> > targetCustomModifiers)
{
if (targetCustomModifiers.IsDefault || targetCustomModifiers.IsEmpty)
{
return(candidateCustomModifiers.IsDefault || candidateCustomModifiers.IsEmpty);
}
else if (candidateCustomModifiers.IsDefault)
{
return(false);
}
var n = candidateCustomModifiers.Length;
if (targetCustomModifiers.Length != n)
{
return(false);
}
for (int i = 0; i < n; i++)
{
var targetCustomModifier = targetCustomModifiers[i];
CustomModifier candidateCustomModifier = candidateCustomModifiers[i];
if (targetCustomModifier.IsOptional != candidateCustomModifier.IsOptional ||
!object.Equals(targetCustomModifier.Modifier, ((CSharpCustomModifier)candidateCustomModifier).ModifierSymbol))
{
return(false);
}
}
return(true);
}
private CustomModifier VisitCustomModifier(CustomModifier modifier)
{
var type = (NamedTypeSymbol)this.Visit((Symbol)modifier.Modifier);
Debug.Assert((object)type != null);
return modifier.IsOptional ?
CSharpCustomModifier.CreateOptional(type) :
CSharpCustomModifier.CreateRequired(type);
}
/*-------------------- Constructors ---------------------------------*/
/// <summary>
/// Create a new custom modifier for a type
/// </summary>
/// <param name="type">the type to be modified</param>
/// <param name="cmod">the modifier</param>
/// <param name="cmodType">the type reference to be associated with the type</param>
public CustomModifiedType(Type type, CustomModifier cmod, Class cmodType)
: base((byte)cmod)
{
Contract.Requires(type != null);
Contract.Requires(cmodType != null);
this.type = type;
this.cmodType = cmodType;
}
internal bool AreEquivalent(
CustomModifier x,
CustomModifier y,
Dictionary <
INamedTypeSymbol,
INamedTypeSymbol
>?equivalentTypesWithDifferingAssemblies
) =>
x.IsOptional == y.IsOptional &&
AreEquivalent(x.Modifier, y.Modifier, equivalentTypesWithDifferingAssemblies);
/// <summary>
/// Create a new custom modifier for a type
/// </summary>
/// <param name="type">the type to be modified</param>
/// <param name="cmod">the modifier</param>
/// <param name="cmodType">the type reference to be associated with the type</param>
public CustomModifiedType(Type type, CustomModifier cmod, Class cmodType)
: base((byte)cmod)
{
this.type = type;
this.cmodType = cmodType;
}
public void Test1()
{
var assemblies = MetadataTestHelpers.GetSymbolsForReferences(mrefs: new[]
{
TestReferences.SymbolsTests.Fields.CSFields.dll,
TestReferences.SymbolsTests.Fields.VBFields.dll,
TestReferences.NetFx.v4_0_21006.mscorlib
},
options: TestOptions.ReleaseDll.WithMetadataImportOptions(MetadataImportOptions.Internal));
var module1 = assemblies[0].Modules[0];
var module2 = assemblies[1].Modules[0];
var module3 = assemblies[2].Modules[0];
var vbFields = module2.GlobalNamespace.GetTypeMembers("VBFields").Single();
var csFields = module1.GlobalNamespace.GetTypeMembers("CSFields").Single();
var f1 = (FieldSymbol)vbFields.GetMembers("F1").Single();
var f2 = (FieldSymbol)vbFields.GetMembers("F2").Single();
var f3 = (FieldSymbol)vbFields.GetMembers("F3").Single();
var f4 = (FieldSymbol)vbFields.GetMembers("F4").Single();
var f5 = (FieldSymbol)vbFields.GetMembers("F5").Single();
var f6 = (FieldSymbol)csFields.GetMembers("F6").Single();
Assert.Equal("F1", f1.Name);
Assert.Same(vbFields.TypeParameters[0], f1.Type);
Assert.False(f1.IsAbstract);
Assert.False(f1.IsConst);
Assert.True(f1.IsDefinition);
Assert.False(f1.IsExtern);
Assert.False(f1.IsOverride);
Assert.False(f1.IsReadOnly);
Assert.False(f1.IsSealed);
Assert.True(f1.IsStatic);
Assert.False(f1.IsVirtual);
Assert.False(f1.IsVolatile);
Assert.Equal(SymbolKind.Field, f1.Kind);
Assert.Equal(module2.Locations, f1.Locations);
Assert.Same(f1, f1.OriginalDefinition);
Assert.Equal(Accessibility.Public, f1.DeclaredAccessibility);
Assert.Same(vbFields, f1.ContainingSymbol);
Assert.Equal(0, f1.CustomModifiers.Length);
Assert.Equal("F2", f2.Name);
Assert.Same(((PEModuleSymbol)module2).GetCorLibType(SpecialType.System_Int32), f2.Type);
Assert.False(f2.IsConst);
Assert.True(f2.IsReadOnly);
Assert.False(f2.IsStatic);
Assert.False(f2.IsVolatile);
Assert.Equal(Accessibility.Protected, f2.DeclaredAccessibility);
Assert.Equal(0, f2.CustomModifiers.Length);
Assert.Equal("F3", f3.Name);
Assert.False(f3.IsConst);
Assert.False(f3.IsReadOnly);
Assert.False(f3.IsStatic);
Assert.False(f3.IsVolatile);
Assert.Equal(Accessibility.Internal, f3.DeclaredAccessibility);
Assert.Equal(0, f3.CustomModifiers.Length);
Assert.Equal("F4", f4.Name);
Assert.False(f4.IsConst);
Assert.False(f4.IsReadOnly);
Assert.False(f4.IsStatic);
Assert.False(f4.IsVolatile);
Assert.Equal(Accessibility.ProtectedOrInternal, f4.DeclaredAccessibility);
Assert.Equal(0, f4.CustomModifiers.Length);
Assert.Equal("F5", f5.Name);
Assert.True(f5.IsConst);
Assert.False(f5.IsReadOnly);
Assert.True(f5.IsStatic);
Assert.False(f5.IsVolatile);
Assert.Equal(Accessibility.Protected, f5.DeclaredAccessibility);
Assert.Equal(0, f5.CustomModifiers.Length);
Assert.Equal("F6", f6.Name);
Assert.False(f6.IsConst);
Assert.False(f6.IsReadOnly);
Assert.False(f6.IsStatic);
Assert.True(f6.IsVolatile);
Assert.Equal(1, f6.CustomModifiers.Length);
CustomModifier mod = f6.CustomModifiers[0];
Assert.False(mod.IsOptional);
Assert.Equal("System.Runtime.CompilerServices.IsVolatile", mod.Modifier.ToTestDisplayString());
Assert.Equal(SymbolKind.NamedType, csFields.GetMembers("FFF").Single().Kind);
Assert.Equal(SymbolKind.Field, csFields.GetMembers("Fff").Single().Kind);
Assert.Equal(SymbolKind.Method, csFields.GetMembers("FfF").Single().Kind);
}
protected IEnumerable<ICustomModifier>/*?*/ GetCustomModifiers(out bool isPinned) {
isPinned = false;
List<ICustomModifier> customModifierList = null;
ICustomModifier customModifier = null;
while (this.SignatureMemoryReader.NotEndOfBytes) {
byte header = this.SignatureMemoryReader.PeekByte(0);
if (header == ElementType.Pinned) {
this.SignatureMemoryReader.SkipBytes(1);
isPinned = true;
continue;
}
if (header != ElementType.RequiredModifier && header != ElementType.OptionalModifier)
break;
this.SignatureMemoryReader.SkipBytes(1);
uint typeDefOrRefEncoded = (uint)this.SignatureMemoryReader.ReadCompressedUInt32();
uint typeToken = TypeDefOrRefTag.ConvertToToken(typeDefOrRefEncoded);
uint tokenType = typeToken & TokenTypeIds.TokenTypeMask;
uint typeRID = typeToken & TokenTypeIds.RIDMask;
ITypeReference/*?*/ typeRef = null;
if (tokenType == TokenTypeIds.TypeDef)
typeRef = this.PEFileToObjectModel.GetTypeDefinitionAtRow(typeRID);
else if (tokenType == TokenTypeIds.TypeRef)
typeRef = this.PEFileToObjectModel.GetTypeRefReferenceAtRow(typeRID);
else
typeRef = this.PEFileToObjectModel.GetTypeSpecReferenceAtRow(this.MetadataOwnerObject, typeRID).UnderlyingModuleTypeReference;
if (typeRef == null) {
// Error...
continue;
}
if (customModifier != null && customModifierList == null) {
customModifierList = new List<ICustomModifier>(4);
customModifierList.Add(customModifier);
}
customModifier = new CustomModifier(header == ElementType.OptionalModifier, typeRef);
if (customModifierList != null) customModifierList.Add(customModifier);
}
if (this.SignatureMemoryReader.RemainingBytes <= 0) {
// TODO: Handle error...
}
if (customModifierList == null) {
if (customModifier == null) return null;
return IteratorHelper.GetSingletonEnumerable(customModifier);
} else {
return IteratorHelper.GetReadonly(customModifierList.ToArray());
}
}
public CustomModifiedType(Type type, CustomModifier cmod, PrimitiveTypeRef cmodType)
: base((byte)cmod)
{
this.type = type;
this.cmodPrimType = cmodType;
}
protected EnumerableArrayWrapper<CustomModifier, ICustomModifier> GetCustomModifiers(
out bool isPinned
) {
isPinned = false;
List<CustomModifier> customModifierList = new List<CustomModifier>();
while (this.SignatureMemoryReader.NotEndOfBytes) {
byte header = this.SignatureMemoryReader.PeekByte(0);
if (header == ElementType.Pinned) {
this.SignatureMemoryReader.SkipBytes(1);
isPinned = true;
continue;
}
if (header != ElementType.RequiredModifier && header != ElementType.OptionalModifier)
break;
this.SignatureMemoryReader.SkipBytes(1);
CustomModifier customModifier;
uint typeDefOrRefEncoded = (uint)this.SignatureMemoryReader.ReadCompressedUInt32();
uint typeToken = TypeDefOrRefTag.ConvertToToken(typeDefOrRefEncoded);
uint tokenType = typeToken & TokenTypeIds.TokenTypeMask;
uint typeRID = typeToken & TokenTypeIds.RIDMask;
ITypeReference/*?*/ typeRef = null;
if (tokenType == TokenTypeIds.TypeDef) {
typeRef = this.PEFileToObjectModel.GetTypeDefinitionAtRow(typeRID);
} else if (tokenType == TokenTypeIds.TypeRef) {
typeRef = this.PEFileToObjectModel.GetTypeRefReferenceAtRow(typeRID);
} else {
typeRef = this.PEFileToObjectModel.GetTypeSpecReferenceAtRow(this.MetadataOwnerObject, typeRID).UnderlyingModuleTypeReference;
}
if (typeRef == null) {
// Error...
continue;
}
customModifier = new CustomModifier(header == ElementType.OptionalModifier, typeRef);
customModifierList.Add(customModifier);
}
if (this.SignatureMemoryReader.RemainingBytes <= 0) {
// TODO: Handle error...
}
if (customModifierList.Count == 0) {
return TypeCache.EmptyCustomModifierArray;
} else {
return new EnumerableArrayWrapper<CustomModifier, ICustomModifier>(customModifierList.ToArray(), Dummy.CustomModifier);
}
}
public static NamedTypeSymbol Modifier(this CustomModifier m)
{
return(((CSharpCustomModifier)m).ModifierSymbol);
}
public void SetModifier(CustomModifier cmod)
{
typeIndex = (byte) cmod;
}
public static string currentDice = "d20"; //default
private void Start()
{
proficiency = GameObject.Find("ProficiencyToggle").GetComponent <Toggle>();
expertise = GameObject.Find("ExpertiseToggle").GetComponent <Toggle>();
customModifier = GameObject.Find("CustomModifier").GetComponent <CustomModifier>();
}
internal bool AreEquivalent(CustomModifier x, CustomModifier y, Dictionary<INamedTypeSymbol, INamedTypeSymbol> equivalentTypesWithDifferingAssemblies)
{
return x.IsOptional == y.IsOptional && AreEquivalent(x.Modifier, y.Modifier, equivalentTypesWithDifferingAssemblies);
}
/*-------------------- Constructors ---------------------------------*/
/// <summary>
/// Create a new custom modifier for a type
/// </summary>
/// <param name="type">the type to be modified</param>
/// <param name="cmod">the modifier</param>
/// <param name="cmodType">the type reference to be associated with the type</param>
public CustomModifiedType(Type type, CustomModifier cmod, Class cmodType)
: base((byte)cmod)
{
Contract.Requires(type != null);
Contract.Requires(cmodType != null);
this.type = type;
this.cmodType = cmodType;
}
public void SetModifier(CustomModifier cmod)
{
typeIndex = (byte)cmod;
}