/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static bool IsDeprecated(this MethodBase method)
{
if (method == null)
{
return(false);
}
// Keep this one line for now but should be removed once the DepreacatedAttribute is deleted
DeprecatedAttribute attribute = method.GetCustomAttribute <DeprecatedAttribute>();
ToBeRemovedAttribute deletedAttribute = method.GetCustomAttribute <ToBeRemovedAttribute>();
ReplacedAttribute replacedAttribute = method.GetCustomAttribute <ReplacedAttribute>();
if (attribute != null || deletedAttribute != null || replacedAttribute != null)
{
return(true);
}
if (method is ConstructorInfo)
{
return(method.DeclaringType.IsDeprecated());
}
return(false);
}
/***************************************************/
public static bool IsDeprecated(this Type type)
{
DeprecatedAttribute attribute = type.GetCustomAttribute <DeprecatedAttribute>();
if (attribute != null)
{
return(true);
}
else
{
return(false);
}
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static bool IsDeprecated(this MethodBase method)
{
DeprecatedAttribute attribute = method.GetCustomAttribute <DeprecatedAttribute>();
if (attribute != null)
{
return(true);
}
else
{
return(false);
}
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static bool IsDeprecated(this MethodBase method)
{
DeprecatedAttribute attribute = method.GetCustomAttribute <DeprecatedAttribute>();
if (attribute != null)
{
return(true);
}
if (method is ConstructorInfo)
{
return(method.DeclaringType.IsDeprecated());
}
return(false);
}
public FieldInfo(ref ReadOnlySpan <byte> data, CPInfo[] constants)
{
AccessFlags = data.ReadTwo();
NameIndex = data.ReadTwo();
DescriptorIndex = data.ReadTwo();
AttributesCount = data.ReadTwo();
AttributeInfo = new AttributeInfo[AttributesCount];
for (int i = 0; i < AttributesCount; i++)
{
ushort nameIndexNonSwapped = MemoryMarshal.Cast <byte, ushort>(data)[0];
ushort nameIndex = nameIndexNonSwapped.SwapEndian();
string name = ((CUtf8Info)constants[nameIndex]).String;
switch (name)
{
case "ConstantValue":
AttributeInfo[i] = new ConstantValueAttribute(ref data, constants);
break;
case "Synthetic":
AttributeInfo[i] = new SyntheticAttribute(ref data, constants);
break;
case "Signature":
AttributeInfo[i] = new SignatureAttribute(ref data, constants);
break;
case "Deprecated":
AttributeInfo[i] = new DeprecatedAttribute(ref data, constants);
Deprecated = true;
break;
case "RuntimeVisibleAnnotations":
AttributeInfo[i] = new RuntimeVisibleAnnotationsAttribute(ref data, constants);
break;
case "RuntimeInvisibleAnnotations":
throw new NotImplementedException();
default:
AttributeInfo[i] = new AttributeInfo(ref data, constants);
break;
}
}
Name = ((CUtf8Info)constants[NameIndex]).String;
Descriptor = ((CUtf8Info)constants[DescriptorIndex]).String;
}
/***************************************************/
public static bool IsDeprecated(this Type type)
{
// Keep this one line for now but should be removed once the DepreacatedAttribute is deleted
DeprecatedAttribute attribute = type.GetCustomAttribute <DeprecatedAttribute>();
ToBeRemovedAttribute deletedAttribute = type.GetCustomAttribute <ToBeRemovedAttribute>();
ReplacedAttribute replacedAttribute = type.GetCustomAttribute <ReplacedAttribute>();
if (attribute != null || deletedAttribute != null || replacedAttribute != null)
{
return(true);
}
else
{
return(false);
}
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static bool IsDeprecated(this MethodBase method)
{
DeprecatedAttribute attribute = method.GetCustomAttribute <DeprecatedAttribute>();
if (attribute != null)
{
try
{
Version version = new Version(attribute.FromVersion);
return(version.CompareTo(method.DeclaringType.Assembly.GetName().Version) <= 0);
}
catch
{
return(true);
}
}
else
{
return(false);
}
}
/***************************************************/
public static bool IsDeprecated(this Type type)
{
DeprecatedAttribute attribute = type.GetCustomAttribute <DeprecatedAttribute>();
if (attribute != null)
{
try
{
Version version = new Version(attribute.FromVersion);
return(version.CompareTo(type.Assembly.GetName().Version) > 0);
}
catch
{
return(true);
}
}
else
{
return(false);
}
}
public MethodInfo(ref ReadOnlySpan <byte> data, ClassFile classFile)
{
AccessFlags = data.ReadTwo();
NameIndex = data.ReadTwo();
Name = ((CUtf8Info)classFile.Constants[NameIndex]).String;
DescriptorIndex = data.ReadTwo();
Descriptor = ((CUtf8Info)classFile.Constants[DescriptorIndex]).String;
AttributesCount = data.ReadTwo();
Attributes = new AttributeInfo[AttributesCount];
for (int i = 0; i < AttributesCount; i++)
{
ushort nameIndexNonSwapped = MemoryMarshal.Cast <byte, ushort>(data)[0];
ushort nameIndex = nameIndexNonSwapped.SwapEndian();
string name = ((CUtf8Info)classFile.Constants[nameIndex]).String;
switch (name)
{
case "Code":
CodeAttribute code = new CodeAttribute(ref data, classFile.Constants);
Attributes[i] = code;
MaxStack = code.MaxStack;
MaxLocals = code.MaxLocals;
CodeAttribute = code;
break;
case "Exceptions":
ExceptionsAttribute exceptionsAttribute = new ExceptionsAttribute(ref data, classFile.Constants);
Attributes[i] = exceptionsAttribute;
ExceptionsAttribute = exceptionsAttribute;
break;
case "Deprecated":
Attributes[i] = new DeprecatedAttribute(ref data, classFile.Constants);
Deprecated = true;
break;
case "RuntimeVisibleAnnotations":
Attributes[i] = new RuntimeVisibleAnnotationsAttribute(ref data, classFile.Constants);
break;
case "Synthetic":
Attributes[i] = new SyntheticAttribute(ref data, classFile.Constants);
break;
case "Signature":
Attributes[i] = new SignatureAttribute(ref data, classFile.Constants);
break;
case "RuntimeInvisibleAnnotations":
case "RuntimeVisibleParameterAnnotations":
case "RuntimeInvisibleParameterAnnotations":
case "AnnotationDefault":
throw new NotImplementedException();
default:
Attributes[i] = new AttributeInfo(ref data, classFile.Constants);
break;
}
}
ClassFile = classFile;
}
public string VisitAttribute(DeprecatedAttribute a)
{
throw new NotImplementedException();
}
public void Deprecated_EmptyConstructor_PropertyCheck()
{
var attrib = new DeprecatedAttribute();
Assert.AreEqual(null, attrib.Reason);
}
private void AttributeSpecifier(IBlockNode scope)
{
DAttribute attr;
Modifier m;
switch (laKind) {
case DTokens.At:
attr = AtAttribute(scope);
break;
case DTokens.Pragma:
attr=_Pragma();
break;
case DTokens.Deprecated:
Step();
var loc = t.Location;
IExpression lc = null;
if(laKind == OpenParenthesis)
{
Step();
lc = AssignExpression(scope);
Expect(CloseParenthesis);
}
attr = new DeprecatedAttribute(loc, t.EndLocation, lc);
break;
case DTokens.Extern:
attr = m = new Modifier (laKind, la.Value) { Location = la.Location };
Step ();
if (laKind == DTokens.OpenParenthesis) {
Step(); // Skip (
var sb = new StringBuilder ();
// Check if EOF and append IncompleteID
while (!IsEOF && laKind != CloseParenthesis)
{
Step();
sb.Append(t.ToString());
if (t.Kind == Identifier && laKind == Identifier)
sb.Append(' ');
}
if (IsEOF)
m.LiteralContent = DTokens.IncompleteId;
else
m.LiteralContent = sb.ToString();
Expect (CloseParenthesis);
}
m.EndLocation = t.EndLocation;
break;
case DTokens.Align:
attr = m = new Modifier (laKind, la.Value) { Location = la.Location };
Step ();
if (laKind == DTokens.OpenParenthesis) {
Step();
if (Expect(Literal))
m.LiteralContent = new IdentifierExpression(t.LiteralValue, t.LiteralFormat);
if (!Expect(CloseParenthesis))
return;
}
m.EndLocation = t.EndLocation;
break;
case DTokens.Package:
attr = m = new Modifier (laKind, la.Value) { Location = la.Location };
Step ();
if (laKind == OpenParenthesis) {
// This isn't documented anywhere. http://dlang.org/attribute.html#ProtectionAttribute
//TODO: Semantically handle this.
Step ();
m.LiteralContent = IdentifierList (scope); // Reassigns a symbol's package/'namespace' or so
Expect (DTokens.CloseParenthesis);
}
m.EndLocation = t.EndLocation;
break;
default:
attr = m = new Modifier (laKind, la.Value) { Location = la.Location };
Step ();
m.EndLocation = t.EndLocation;
break;
}
//TODO: What about these semicolons after e.g. a pragma? Enlist these attributes anyway in the meta decl list?
if (laKind != Semicolon)
{
if (scope is DBlockNode)
AttributeSpecifier(scope as DBlockNode, attr);
else
PushAttribute(attr, false);
}
}
static Dictionary <TypeId, EnumType> CreateEnumsDict(Assembly assembly)
{
var allTypeIds = typeof(TypeIds).GetFields().Select(a => (TypeId)a.GetValue(null) !).ToHashSet();
var enums = new Dictionary <TypeId, EnumType>();
foreach (var type in assembly.GetTypes())
{
var ca = type.GetCustomAttribute <EnumAttribute>(false);
if (ca is null)
{
continue;
}
if (!allTypeIds.Contains(ca.TypeId))
{
throw new InvalidOperationException();
}
allTypeIds.Remove(ca.TypeId);
var flags = EnumTypeFlags.None;
if (ca.Public)
{
flags |= EnumTypeFlags.Public;
}
if (ca.NoInitialize)
{
flags |= EnumTypeFlags.NoInitialize;
}
if (ca.Flags)
{
flags |= EnumTypeFlags.Flags;
}
var values = type.GetFields().Where(a => a.IsLiteral).Select(a => new EnumValue(GetValue(a.GetValue(null)), a.Name, CommentAttribute.GetDocumentation(a), DeprecatedAttribute.GetDeprecatedInfo(a))).ToArray();
var enumType = new EnumType(ca.Name, ca.TypeId, ca.Documentation, values, flags);
enums.Add(ca.TypeId, enumType);
}
return(enums);
}
public ulong VisitAttribute(DeprecatedAttribute a)
{
return(1000159);
}
public AbstractType VisitAttribute(DeprecatedAttribute a)
{
throw new NotImplementedException();
}
private void AttributeSpecifier(IBlockNode scope)
{
DAttribute attr;
if(laKind == At)
attr = AtAttribute(scope);
else if (laKind == Pragma)
attr=_Pragma();
else if(laKind == Deprecated)
{
Step();
var loc = t.Location;
IExpression lc = null;
if(laKind == OpenParenthesis)
{
Step();
lc = AssignExpression(scope);
Expect(CloseParenthesis);
}
attr = new DeprecatedAttribute(loc, t.EndLocation, lc);
}
else
{
var m = new Modifier(laKind, la.Value) { Location = la.Location };
attr = m;
if (laKind == Extern && Lexer.CurrentPeekToken.Kind == OpenParenthesis)
{
Step(); // Skip extern
Step(); // Skip (
var sb = new StringBuilder ();
// Check if EOF and append IncompleteID
while (!IsEOF && laKind != CloseParenthesis)
{
Step();
sb.Append(t.ToString());
if (t.Kind == Identifier && laKind == Identifier)
sb.Append(' ');
}
if (IsEOF)
m.LiteralContent = DTokens.IncompleteId;
else
m.LiteralContent = sb.ToString();
Expect (CloseParenthesis);
}
else if (laKind == Align && Lexer.CurrentPeekToken.Kind == OpenParenthesis)
{
Step();
Step();
if (Expect(Literal))
m.LiteralContent = new IdentifierExpression(t.LiteralValue, t.LiteralFormat);
if (!Expect(CloseParenthesis))
return;
}
else
Step();
m.EndLocation = t.EndLocation;
}
//TODO: What about these semicolons after e.g. a pragma? Enlist these attributes anyway in the meta decl list?
if (laKind != Semicolon)
AttributeTrail (scope as DBlockNode, attr);
}
public void Deprecated_WithReason_PropertyCheck()
{
var attrib = new DeprecatedAttribute("Because");
Assert.AreEqual("Because", attrib.Reason);
}
/// <summary>
/// Read a list of attributes
/// </summary>
private void ReadAttributes(ConstantPool cp, IModifiableAttributeProvider provider)
{
var count = stream.ReadU2();
for (var i = 0; i < count; i++)
{
var nameIndex = stream.ReadU2();
var name = cp.GetEntry <ConstantPoolUtf8>(nameIndex).Value;
var length = stream.ReadU4();
Attribute attr;
int tmp;
switch (name)
{
case CodeAttribute.AttributeName:
attr = ReadCodeAttribute((MethodDefinition)provider, cp);
break;
case ConstantValueAttribute.AttributeName:
tmp = stream.ReadU2();
attr = new ConstantValueAttribute(((IConstantPoolValue)cp[tmp]).Value);
break;
case ExceptionsAttribute.AttributeName:
attr = ReadExceptionsAttribute(cp);
break;
case InnerClassesAttribute.AttributeName:
attr = ReadInnerClassesAttribute(cp);
break;
case SyntheticAttribute.AttributeName:
attr = new SyntheticAttribute();
break;
case SourceFileAttribute.AttributeName:
tmp = stream.ReadU2();
attr = new SourceFileAttribute(cp.GetEntry <ConstantPoolUtf8>(tmp).Value);
break;
case LineNumberTableAttribute.AttributeName:
attr = ReadLineNumberTableAttribute();
break;
case LocalVariableTableAttribute.AttributeName:
attr = ReadLocalVariableTableAttribute(cp);
break;
case DeprecatedAttribute.AttributeName:
attr = new DeprecatedAttribute();
break;
case OverrideAttribute.AttributeName:
attr = new OverrideAttribute();
break;
case SignatureAttribute.AttributeName:
tmp = stream.ReadU2();
attr = new SignatureAttribute(cp.GetEntry <ConstantPoolUtf8>(tmp).Value);
break;
case RuntimeVisibleAnnotationsAttribute.AttributeName:
attr = new RuntimeVisibleAnnotationsAttribute(ReadAnnotationsAttribute(cp));
break;
case RuntimeInvisibleAnnotationsAttribute.AttributeName:
attr = new RuntimeInvisibleAnnotationsAttribute(ReadAnnotationsAttribute(cp));
break;
case RuntimeVisibleParameterAnnotationsAttribute.AttributeName:
attr = new RuntimeVisibleParameterAnnotationsAttribute(ReadAnnotationsAttribute(cp));
break;
case RuntimeInvisibleParameterAnnotationsAttribute.AttributeName:
attr = new RuntimeInvisibleParameterAnnotationsAttribute(ReadAnnotationsAttribute(cp));
break;
case AnnotationDefaultAttribute.AttributeName:
attr = new AnnotationDefaultAttribute(ReadElementValue(cp));
break;
default:
stream.Skip(length);
attr = new UnknownAttribute(name);
break;
}
provider.Add(attr);
}
provider.AttributesLoaded();
}
public void Deprecated_WithReason_IsTrimmed()
{
var attrib = new DeprecatedAttribute(" Because ");
Assert.AreEqual("Because", attrib.Reason);
}
public virtual void VisitAttribute(DeprecatedAttribute a)
{
}
public CompletionItemKind VisitAttribute(DeprecatedAttribute a)
{
throw new NotImplementedException();
}