public CodeGenerator(AttributeData attributeData)
{
Requires.NotNull(attributeData, nameof(attributeData));
this.attributeData = attributeData;
this.data = this.attributeData.NamedArguments.ToImmutableDictionary(kv => kv.Key, kv => kv.Value);
}
private RoslynAttributeMetadata(AttributeData a)
{
var declaration = a.ToString();
var index = declaration.IndexOf("(", StringComparison.Ordinal);
this.symbol = a.AttributeClass;
this.name = symbol.Name;
if (index > -1)
{
this.value = declaration.Substring(index + 1, declaration.Length - index - 2);
// Trim {} from params
if (this.value.EndsWith("\"}"))
{
this.value = this.value.Remove(this.value.LastIndexOf("{\"", StringComparison.Ordinal), 1);
this.value = this.value.TrimEnd('}');
}
else if (this.value.EndsWith("}"))
{
this.value = this.value.Remove(this.value.LastIndexOf("{", StringComparison.Ordinal), 1);
this.value = this.value.TrimEnd('}');
}
}
if (name.EndsWith("Attribute"))
name = name.Substring(0, name.Length - 9);
}
public string ConvertToMessage(AttributeData attributeData)
{
var stringBuilder = new StringBuilder();
var message = attributeData.Message;
if (message != null)
{
message = message.Trim();
message = message.Trim('.');
stringBuilder.AppendFormat("{0}. ", message);
}
if (attributeData.Replacement != null)
{
stringBuilder.AppendFormat(ReplacementFormat, attributeData.Replacement);
}
if (assemblyVersion < attributeData.TreatAsErrorFromVersion)
{
stringBuilder.AppendFormat(TreatAsErrorFormat, attributeData.TreatAsErrorFromVersion.ToSemVer());
}
if (attributeData.ThrowsNotImplemented)
{
stringBuilder.Append(ThrowsNotImplementedText);
}
stringBuilder.AppendFormat(RemoveInVersionFormat, attributeData.RemoveInVersion.ToSemVer());
return stringBuilder.ToString().Trim();
}
public LockInfo(
FieldDeclarationSyntax declaration,
FieldSymbol symbol,
AttributeData associatedAttribute,
SemanticModel semanticModel)
: base(declaration, symbol, associatedAttribute, semanticModel)
{
}
public static AttributeRemoveAction Create(
AttributeData attribute,
Project project,
Diagnostic diagnostic,
AbstractSuppressionCodeFixProvider fixer)
{
return new AttributeRemoveAction(attribute, project, diagnostic, fixer);
}
public GuardedFieldInfo(
FieldDeclarationSyntax declaration,
FieldSymbol symbol,
AttributeData associatedAttribute,
SemanticModel semanticModel)
: base(declaration, symbol, associatedAttribute, semanticModel)
{
_declaredLockHierarchy = LockHierarchy.FromStringList(Attribute.ConstructorArguments.SelectMany(arg => arg.Values.Select(argVal => argVal.Value.ToString())).ToList());
}
private static AttributeListSyntax GenerateAttributeDeclaration(
AttributeData attribute, SyntaxToken? target, CodeGenerationOptions options)
{
var attributeSyntax = GenerateAttribute(attribute, options);
return attributeSyntax == null
? null
: SyntaxFactory.AttributeList(
target.HasValue ? SyntaxFactory.AttributeTargetSpecifier(target.Value) : null,
SyntaxFactory.SingletonSeparatedList(attributeSyntax));
}
private AttributeRemoveAction(
AttributeData attribute,
Project project,
Diagnostic diagnostic,
AbstractSuppressionCodeFixProvider fixer,
bool forFixMultipleContext = false)
: base(diagnostic, fixer, forFixMultipleContext)
{
_project = project;
_attribute = attribute;
}
bool GetIsError(AttributeData attributeData)
{
if (attributeData.TreatAsErrorFromVersion != null)
{
if (assemblyVersion >= attributeData.TreatAsErrorFromVersion)
{
return true;
}
}
return false;
}
public override StatementSyntax EmitGuard(AttributeData attribute, TypeSymbol parameterType, string parameterName)
{
//TODO: Consider how to properly handle type conversions
StatementSyntax guardStatement = Syntax.IfStatement(
SimpleSyntaxWriter.InvokeStaticMethod(
()=>string.IsNullOrWhiteSpace(Fake.String),
SimpleSyntaxWriter.ArgumentFromIdentifier(parameterName)),
Syntax.Block(
SimpleSyntaxWriter.GenerateThrowStatement(typeof(ArgumentException), parameterName, string.Format(@"""{0} cannot be null, empty or whitespace""", parameterName))));
return guardStatement;
}
public override StatementSyntax EmitGuard(AttributeData attribute, TypeSymbol parameterType, string parameterName)
{
StatementSyntax guardStatement = Syntax.IfStatement(
Syntax.BinaryExpression(
SyntaxKind.EqualsExpression,
Syntax.IdentifierName(parameterName),
Syntax.IdentifierName("null")),
Syntax.Block(
SimpleSyntaxWriter.GenerateThrowStatement(typeof(ArgumentNullException), parameterName)));
return guardStatement;
}
public void AttributeData_Ctor()
{
AttributeData data;
Console.WriteLine("Test with optional value and no default value.");
data = new AttributeData("test", new XmlNameInfo("name"), true);
Assert.IsNotNull(data.InheritanceList, "InheritanceList is not null.");
Assert.AreEqual(0, data.InheritanceList.Count, "InheritanceList count is incorrect.");
Assert.IsNull(data.ConverterTypeName, "ConverterTypeName is not null.");
Assert.IsFalse(data.HasValue, "HasValue is incorrect.");
Assert.IsFalse(data.InheritValue, "InheritValue is incorrect.");
Assert.IsFalse(data.IsDefaultValue, "IsDefaultValue is incorrect.");
Assert.IsTrue(data.IsOptional, "IsOptional is incorrect.");
Assert.IsNull(data.Value, "Value is incorrect.");
Assert.AreEqual("name", data.LocalName, "XmlName is incorrect.");
Console.WriteLine("Test with required value and no default value.");
data = new AttributeData("test", new XmlNameInfo("name"), false);
Assert.IsNotNull(data.InheritanceList, "InheritanceList is not null.");
Assert.AreEqual(0, data.InheritanceList.Count, "InheritanceList count is incorrect.");
Assert.IsNull(data.ConverterTypeName, "ConverterTypeName is not null.");
Assert.IsFalse(data.HasValue, "HasValue is incorrect.");
Assert.IsFalse(data.InheritValue, "InheritValue is incorrect.");
Assert.IsFalse(data.IsDefaultValue, "IsDefaultValue is incorrect.");
Assert.IsFalse(data.IsOptional, "IsOptional is incorrect.");
Assert.IsNull(data.Value, "Value is incorrect.");
Assert.AreEqual("name", data.LocalName, "XmlName is incorrect.");
Console.WriteLine("Test with optional value and default value.");
data = new AttributeData("test", new XmlNameInfo("name"), true, 1);
Assert.IsNotNull(data.InheritanceList, "InheritanceList is not null.");
Assert.AreEqual(0, data.InheritanceList.Count, "InheritanceList count is incorrect.");
Assert.IsNull(data.ConverterTypeName, "ConverterTypeName is not null.");
Assert.IsFalse(data.HasValue, "HasValue is incorrect.");
Assert.IsFalse(data.InheritValue, "InheritValue is incorrect.");
Assert.IsTrue(data.IsDefaultValue, "IsDefaultValue is incorrect.");
Assert.IsTrue(data.IsOptional, "IsOptional is incorrect.");
Assert.AreEqual(1, data.Value, "Value is incorrect.");
Assert.AreEqual("name", data.LocalName, "XmlName is incorrect.");
Console.WriteLine("Test with required value and default value.");
data = new AttributeData("test", new XmlNameInfo("name"), false, 1);
Assert.IsNotNull(data.InheritanceList, "InheritanceList is not null.");
Assert.AreEqual(0, data.InheritanceList.Count, "InheritanceList count is incorrect.");
Assert.IsNull(data.ConverterTypeName, "ConverterTypeName is not null.");
Assert.IsTrue(data.HasValue, "HasValue is incorrect.");
Assert.IsFalse(data.InheritValue, "InheritValue is incorrect.");
Assert.IsTrue(data.IsDefaultValue, "IsDefaultValue is incorrect.");
Assert.IsFalse(data.IsOptional, "IsOptional is incorrect.");
Assert.AreEqual(1, data.Value, "Value is incorrect.");
Assert.AreEqual("name", data.LocalName, "XmlName is incorrect.");
}
public override StatementSyntax EmitGuard(AttributeData attribute, TypeSymbol parameterType, string parameterName)
{
//TODO: Modify to try cast to IList first, then try cast to IEnumerable
StatementSyntax guardStatement = Syntax.IfStatement(
Syntax.BinaryExpression(
SyntaxKind.LessThanOrEqualExpression,
SimpleSyntaxWriter.AccessMemberWithCast((IList x)=>x.Count, parameterName),
Syntax.IdentifierName("0")),
Syntax.Block(
SimpleSyntaxWriter.GenerateThrowStatement(typeof(ArgumentException), parameterName, string.Format(@"""{0} cannot be empty""", parameterName))));
return guardStatement;
}
public void All()
{
var attributeData = new AttributeData
{
Message = "Custom Message.",
TreatAsErrorFromVersion = "2",
RemoveInVersion = "4",
Replacement = "NewMember"
};
SemanticVersion assemblyVersion = "1";
var dataFormatter = new ModuleWeaver {assemblyVersion = assemblyVersion};
var message = dataFormatter.ConvertToMessage(attributeData);
Assert.AreEqual("Custom Message. Use `NewMember` instead. Will be treated as an error from version 2.0.0. Will be removed in version 4.0.0.", message);
}
public void ForSample()
{
var attributeData = new AttributeData
{
Message = "Custom Message.",
TreatAsErrorFromVersion = "2",
RemoveInVersion = "4",
Replacement = "NewClass"
};
var dataFormatter1 = new ModuleWeaver { assemblyVersion = "1"};
Debug.WriteLine(dataFormatter1.ConvertToMessage(attributeData));
var dataFormatter2 = new ModuleWeaver { assemblyVersion = "3"};
Debug.WriteLine(dataFormatter2.ConvertToMessage(attributeData));
}
void AddObsoleteAttribute(AttributeData attributeData, Collection<CustomAttribute> customAttributes)
{
var customAttribute = new CustomAttribute(ObsoleteConstructorReference);
var message = ConvertToMessage(attributeData);
var messageArgument = new CustomAttributeArgument(ModuleDefinition.TypeSystem.String, message);
customAttribute.ConstructorArguments.Add(messageArgument);
var isError = GetIsError(attributeData);
var isErrorArgument = new CustomAttributeArgument(ModuleDefinition.TypeSystem.Boolean, isError);
customAttribute.ConstructorArguments.Add(isErrorArgument);
customAttributes.Add(customAttribute);
}
private RoslynAttributeMetadata(AttributeData a)
{
var declaration = a.ToString();
var index = declaration.IndexOf("(", StringComparison.Ordinal);
this.symbol = a.AttributeClass;
this.name = symbol.Name;
if (index > -1)
this.value = declaration.Substring(index + 1, declaration.Length - index - 2);
if (name.EndsWith("Attribute"))
name = name.Substring(0, name.Length - 9);
}
private static AttributeSyntax GenerateAttribute(AttributeData attribute, CodeGenerationOptions options)
{
if (!options.MergeAttributes)
{
var reusableSyntax = GetReuseableSyntaxNodeForAttribute<AttributeSyntax>(attribute, options);
if (reusableSyntax != null)
{
return reusableSyntax;
}
}
var attributeArguments = GenerateAttributeArgumentList(attribute);
var nameSyntax = attribute.AttributeClass.GenerateTypeSyntax() as NameSyntax;
return nameSyntax == null ? null : SyntaxFactory.Attribute(nameSyntax, attributeArguments);
}
public override StatementSyntax EmitGuard(AttributeData attribute, TypeSymbol parameterType, string parameterName)
{
string comparisonValue = attribute.ConstructorArguments.First().Value.ToString();
StatementSyntax guardStatement = Syntax.IfStatement(
Syntax.BinaryExpression(
SyntaxKind.GreaterThanOrEqualExpression,
SimpleSyntaxWriter.InvokeMethodWithCast(
(IComparable x)=>x.CompareTo(Fake.Object),
parameterName,
SimpleSyntaxWriter.ArgumentFromLiteral(comparisonValue, false)),
Syntax.IdentifierName("0")),
Syntax.Block(
SimpleSyntaxWriter.GenerateThrowStatement(typeof(ArgumentException), parameterName, string.Format(@"""{0} is not less than '" + comparisonValue + @"'.""", parameterName))));
return guardStatement;
}
public override StatementSyntax EmitGuard(AttributeData attribute, TypeSymbol parameterType, string parameterName)
{
//TODO: Consider how to properly handle type conversions
StatementSyntax guardStatement = Syntax.IfStatement(
Syntax.BinaryExpression(
SyntaxKind.EqualsExpression,
SimpleSyntaxWriter.InvokeStaticMethod(
() => Enum.IsDefined(Fake.Any<Type>(), Fake.Object),
SimpleSyntaxWriter.ArgumentFromTypeof(parameterType.Name),
SimpleSyntaxWriter.ArgumentFromLiteral(parameterName, false)
),
Syntax.IdentifierName("false")),
Syntax.Block(
SimpleSyntaxWriter.GenerateThrowStatement(typeof(ArgumentException), parameterName, string.Format(@"""{0} value is not defined for the enum type.""", parameterName))));
return guardStatement;
}
void ApplyVersionConvention(AttributeData attributeData)
{
if (attributeData.TreatAsErrorFromVersion == null)
{
if (attributeData.RemoveInVersion == null)
{
attributeData.TreatAsErrorFromVersion = assemblyVersion.Increment(StepType);
}
else
{
attributeData.TreatAsErrorFromVersion = attributeData.RemoveInVersion.Decrement(StepType);
}
}
if (attributeData.RemoveInVersion == null)
{
attributeData.RemoveInVersion = attributeData.TreatAsErrorFromVersion.Increment(StepType);
}
}
private static AttributeArgumentListSyntax GenerateAttributeArgumentList(AttributeData attribute)
{
if (attribute.ConstructorArguments.Length == 0 && attribute.NamedArguments.Length == 0)
{
return null;
}
var arguments = new List<AttributeArgumentSyntax>();
arguments.AddRange(attribute.ConstructorArguments.Select(c =>
SyntaxFactory.AttributeArgument(GenerateExpression(c))));
arguments.AddRange(attribute.NamedArguments.Select(kvp =>
SyntaxFactory.AttributeArgument(
SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(kvp.Key)), null,
GenerateExpression(kvp.Value))));
return SyntaxFactory.AttributeArgumentList(SyntaxFactory.SeparatedList(arguments));
}
public override StatementSyntax EmitGuard(AttributeData attribute, TypeSymbol parameterType, string parameterName)
{
//TODO: Make defensive incase no argument supplied
string regexMatchString = attribute.ConstructorArguments.First().Value.ToString();
StatementSyntax guardStatement = Syntax.IfStatement(
Syntax.BinaryExpression(
SyntaxKind.EqualsExpression,
SimpleSyntaxWriter.InvokeStaticMethod(
() => Regex.IsMatch(Fake.String, Fake.String),
SimpleSyntaxWriter.ArgumentFromIdentifier(parameterName),
SimpleSyntaxWriter.ArgumentFromLiteral(regexMatchString, true)
),
Syntax.IdentifierName("false")),
Syntax.Block(
SimpleSyntaxWriter.GenerateThrowStatement(typeof(ArgumentException), parameterName, string.Format(@"""{0} does not match the regular expression '" + regexMatchString + @"'.""", parameterName))));
return guardStatement;
}
/// <summary>
/// Try to map one Attribute to Attribute specifications.
/// </summary>
/// <param name="attribute">The actual Attribute to map.</param>
/// <param name="sortedAttributeListSpecification">The Attribute specifications to map to.</param>
/// <returns>
/// Indicates if the supplied actual Attribute and it's direct and indirect
/// Attribute childs have been mapped.
/// </returns>
public static bool Map(Attribute attribute, SortedAttributeListSpecification sortedAttributeListSpecification)
{
bool attributesMapped = true;
//
// Determine which attribute specification instances have the same tag and level.
//
AttributeData attributeData = new AttributeData();
attribute.Data = attributeData;
attributeData.Mapping = sortedAttributeListSpecification.GetAttributes(attribute.Tag.GroupNumber, attribute.Tag.ElementNumber);
if (attributeData.Mapping.Count == 0)
{
attributesMapped = false;
}
//
// If this attribute is a Sequence Attribute, also map its children.
//
if (attribute is SequenceAttribute)
{
SequenceAttribute sequenceAttribute = attribute as SequenceAttribute;
SortedAttributeListSpecification sequenceItemSpecification = GetSequenceItemSpecification(attributeData.Mapping);
foreach (SequenceItem sequenceItem in sequenceAttribute.SequenceItems)
{
bool sequenceItemMapped = Map(sequenceItem, sequenceItemSpecification);
attributesMapped = (attributesMapped && sequenceItemMapped);
}
}
attributeData.AttributesMapped = attributesMapped;
return (attributesMapped);
}
public void AttributeData_GetStringValue()
{
AttributeData data;
data = new AttributeData("test", new XmlNameInfo("name"), true);
Console.WriteLine("Test with null value.");
Assert.IsNull(data.GetStringValue(), "Value is not null.");
Console.WriteLine("Test with string value.");
data.Value = "string";
Assert.AreEqual("string", data.GetStringValue(), "Value is incorrect.");
Console.WriteLine("Test with int value.");
data.Value = 1;
Assert.AreEqual("1", data.GetStringValue(), "Value is incorrect.");
Console.WriteLine("Test with converter.");
data.ConverterTypeName = typeof(HexConverter).FullName;
data.Value = 10;
Assert.AreEqual("000A", data.GetStringValue(), "Value is incorrect.");
}
private static bool IsLocalizableAttribute(AttributeData attributeData)
{
return(attributeData.AttributeClass.Is(KnownType.System_ComponentModel_LocalizableAttribute) &&
attributeData.ConstructorArguments.Any(c => (c.Value as bool?) ?? false));
}
public override void Serialize(AttributeData data)
{
data.WriteAttribute("UnitMmScale", _unitMmScale);
}
/// <summary>기본 생성자</summary>
public AZList()
{
list = new List <AZData>();
attribute_data = new AttributeData();
}
public override void ReportInvalidAttributeArgument(DiagnosticBag diagnostics, SyntaxNode attributeSyntax, int parameterIndex, AttributeData attribute)
{
var node = (AttributeSyntax)attributeSyntax;
CSharpSyntaxNode attributeArgumentSyntax = attribute.GetAttributeArgumentSyntax(parameterIndex, node);
diagnostics.Add(ErrorCode.ERR_InvalidAttributeArgument, attributeArgumentSyntax.Location, node.GetErrorDisplayName());
}
public static DeclaredApiResponseMetadata ForProducesDefaultResponse(AttributeData attributeData, IMethodSymbol attributeSource)
{
return(new DeclaredApiResponseMetadata(statusCode: 0, attributeData, attributeSource, @implicit: false, @default: true));
}
public void AnalyzeSymbol(SymbolAnalysisContext context)
{
var methodSymbol = (IMethodSymbol)context.Symbol;
if (methodSymbol == null)
{
return;
}
DllImportData dllImportData = methodSymbol.GetDllImportData();
if (dllImportData == null)
{
return;
}
AttributeData dllAttribute = methodSymbol.GetAttributes().FirstOrDefault(attr => attr.AttributeClass.Equals(_dllImportType));
Location defaultLocation = dllAttribute == null?methodSymbol.Locations.FirstOrDefault() : GetAttributeLocation(dllAttribute);
// CA1401 - PInvoke methods should not be visible
if (methodSymbol.IsExternallyVisible())
{
context.ReportDiagnostic(context.Symbol.CreateDiagnostic(RuleCA1401, methodSymbol.Name));
}
// CA2101 - Specify marshalling for PInvoke string arguments
if (dllImportData.BestFitMapping != false)
{
bool appliedCA2101ToMethod = false;
foreach (IParameterSymbol parameter in methodSymbol.Parameters)
{
if (parameter.Type.SpecialType == SpecialType.System_String || parameter.Type.Equals(_stringBuilderType))
{
AttributeData marshalAsAttribute = parameter.GetAttributes().FirstOrDefault(attr => attr.AttributeClass.Equals(_marshalAsType));
CharSet? charSet = marshalAsAttribute == null
? dllImportData.CharacterSet
: MarshalingToCharSet(GetParameterMarshaling(marshalAsAttribute));
// only unicode marshaling is considered safe
if (charSet != CharSet.Unicode)
{
if (marshalAsAttribute != null)
{
// track the diagnostic on the [MarshalAs] attribute
Location marshalAsLocation = GetAttributeLocation(marshalAsAttribute);
context.ReportDiagnostic(Diagnostic.Create(RuleCA2101, marshalAsLocation));
}
else if (!appliedCA2101ToMethod)
{
// track the diagnostic on the [DllImport] attribute
appliedCA2101ToMethod = true;
context.ReportDiagnostic(Diagnostic.Create(RuleCA2101, defaultLocation));
}
}
}
}
// only unicode marshaling is considered safe, but only check this if we haven't already flagged the attribute
if (!appliedCA2101ToMethod && dllImportData.CharacterSet != CharSet.Unicode &&
(methodSymbol.ReturnType.SpecialType == SpecialType.System_String || methodSymbol.ReturnType.Equals(_stringBuilderType)))
{
context.ReportDiagnostic(Diagnostic.Create(RuleCA2101, defaultLocation));
}
}
}
public override void Deserialize(AttributeData data)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="OfferFriendlyOverloadsGenerator"/> class.
/// </summary>
/// <param name="data">Generator attribute data.</param>
public OfferFriendlyOverloadsGenerator(AttributeData data)
{
}
private static void AnalyzeServerSideOperation(SymbolAnalysisContext context, ISymbol methodSymbol, string clientOperationName, AttributeData rpcServiceAttribute)
{
var serverDefinitionType = rpcServiceAttribute.NamedArguments.FirstOrDefault(pair => pair.Key == "ServerDefinitionType").Value;
if (!serverDefinitionType.IsNull)
{
if (!string.IsNullOrEmpty(clientOperationName))
{
if (serverDefinitionType.Value is ITypeSymbol serverTypeSymbol)
{
bool hasServerOperation = false;
foreach (var serverOp in EnumRpcOperations(serverTypeSymbol))
{
if (clientOperationName == serverOp.OperationName)
{
hasServerOperation = true;
break;
}
}
if (!hasServerOperation)
{
var mbrDiagnostic = Diagnostic.Create(RpcMissingServerOperationRule, methodSymbol.Locations[0], clientOperationName);
context.ReportDiagnostic(mbrDiagnostic);
}
}
}
}
}
private static void Analyze(Action <Diagnostic> reportDiagnostic, AttributeData attributeData)
{
var attributeConstructor = attributeData.AttributeConstructor;
var constructorArguments = attributeData.ConstructorArguments;
if (attributeConstructor == null || attributeConstructor.Parameters.Count() != constructorArguments.Count())
{
return;
}
var syntax = attributeData.ApplicationSyntaxReference.GetSyntax();
for (int i = 0; i < attributeConstructor.Parameters.Count(); i++)
{
var parameter = attributeConstructor.Parameters[i];
if (parameter.Type.SpecialType != SpecialType.System_String)
{
continue;
}
// If the name of the parameter is not something which requires the value-passed
// to the parameter to be validated then we don't have to do anything
var valueValidator = GetValueValidator(parameter.Name);
if (valueValidator != null && !valueValidator.IsIgnoredName(parameter.Name))
{
if (constructorArguments[i].Value != null)
{
var value = (string)constructorArguments[i].Value;
string classDisplayString = attributeData.AttributeClass.ToDisplayString(SymbolDisplayFormats.ShortSymbolDisplayFormat);
if (value.Equals(string.Empty, StringComparison.Ordinal))
{
reportDiagnostic(syntax.CreateDiagnostic(EmptyRule,
classDisplayString,
parameter.Name,
valueValidator.TypeName));
}
else if (!valueValidator.IsValidValue(value))
{
reportDiagnostic(syntax.CreateDiagnostic(DefaultRule,
classDisplayString,
parameter.Name,
value,
valueValidator.TypeName));
}
}
}
}
foreach (var namedArgument in attributeData.NamedArguments)
{
if (namedArgument.Value.IsNull ||
namedArgument.Value.Type.SpecialType != SpecialType.System_String)
{
return;
}
var valueValidator = GetValueValidator(namedArgument.Key);
if (valueValidator != null && !valueValidator.IsIgnoredName(namedArgument.Key))
{
var value = (string)(namedArgument.Value.Value);
string classDisplayString = attributeData.AttributeClass.ToDisplayString(SymbolDisplayFormats.ShortSymbolDisplayFormat);
if (value.Equals(string.Empty, StringComparison.Ordinal))
{
reportDiagnostic(syntax.CreateDiagnostic(EmptyRule,
classDisplayString,
$"{classDisplayString}.{namedArgument.Key}",
valueValidator.TypeName));
}
else if (!valueValidator.IsValidValue(value))
{
reportDiagnostic(syntax.CreateDiagnostic(DefaultRule,
classDisplayString,
$"{classDisplayString}.{namedArgument.Key}",
value,
valueValidator.TypeName));
}
}
}
}
public override void ReportMarshalUnmanagedTypeOnlyValidForFields(DiagnosticBag diagnostics, SyntaxNode attributeSyntax, int parameterIndex, string unmanagedTypeName, AttributeData attribute)
{
throw new NotImplementedException();
}
private static bool TryDecodeSuppressMessageAttributeData(AttributeData attribute, out SuppressMessageInfo info)
{
info = default(SuppressMessageInfo);
// We need at least the Category and Id to decode the diagnostic to suppress.
// The only SuppressMessageAttribute constructor requires those two parameters.
if (attribute.CommonConstructorArguments.Length < 2)
{
return false;
}
// Ignore the category parameter because it does not identify the diagnostic
// and category information can be obtained from diagnostics themselves.
info.Id = attribute.CommonConstructorArguments[1].Value as string;
if (info.Id == null)
{
return false;
}
// Allow an optional human-readable descriptive name on the end of an Id.
// See http://msdn.microsoft.com/en-us/library/ms244717.aspx
var separatorIndex = info.Id.IndexOf(':');
if (separatorIndex != -1)
{
info.Id = info.Id.Remove(separatorIndex);
}
info.Scope = attribute.DecodeNamedArgument<string>("Scope", SpecialType.System_String);
info.Target = attribute.DecodeNamedArgument<string>("Target", SpecialType.System_String);
info.MessageId = attribute.DecodeNamedArgument<string>("MessageId", SpecialType.System_String);
return true;
}
/// <summary>
/// Removes the specified attribute node from the given declaration node.
/// </summary>
public static TDeclarationNode RemoveAttribute <TDeclarationNode>(TDeclarationNode destination, Workspace workspace, AttributeData attributeToRemove, CodeGenerationOptions options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode
{
return(GetCodeGenerationService(workspace, destination.Language).RemoveAttribute(destination, attributeToRemove, options ?? CodeGenerationOptions.Default, cancellationToken));
}
[DllImport("usdi")] public static extern bool usdiAttrWriteSample(Attribute attr, ref AttributeData src, double t);
[DllImport("usdi")] public static extern bool usdiAttrReadSample(Attribute attr, ref AttributeData dst, double t, Bool copy);
public override bool IsMatch(AttributeData value)
{
return(!AttributeNames.Contains(value.AttributeClass));
}
public override void Deserialize(AttributeData data)
{
UnitMmScale = data.ReadAttributeDouble("UnitMmScale");
}
private static void AnalyzeServerSideMethod(SymbolAnalysisContext context, IMethodSymbol methodSymbol, AttributeData rpcServiceAttribute)
{
if (methodSymbol.AssociatedSymbol != null)
{
return;
}
string clientOperationName = GetOperationNameFromMemberSymbol(methodSymbol);
AnalyzeServerSideOperation(context, methodSymbol, clientOperationName, rpcServiceAttribute);
}
public static DeclaredApiResponseMetadata ForProducesResponseType(int statusCode, AttributeData attributeData, IMethodSymbol attributeSource)
{
return(new DeclaredApiResponseMetadata(statusCode, attributeData, attributeSource, @implicit: false, @default: false));
}
private void ConfigureDictionaryBoundAttribute(
BoundAttributeDescriptorBuilder builder,
IPropertySymbol property,
INamedTypeSymbol containingType,
AttributeData attributeNameAttribute,
string attributeName,
bool hasPublicSetter)
{
string dictionaryAttributePrefix = null;
var dictionaryAttributePrefixSet = false;
if (attributeNameAttribute != null)
{
foreach (var argument in attributeNameAttribute.NamedArguments)
{
if (argument.Key == TagHelperTypes.HtmlAttributeName.DictionaryAttributePrefix)
{
dictionaryAttributePrefix = (string)argument.Value.Value;
dictionaryAttributePrefixSet = true;
break;
}
}
}
var dictionaryArgumentTypes = GetDictionaryArgumentTypes(property);
if (dictionaryArgumentTypes != null)
{
var prefix = dictionaryAttributePrefix;
if (attributeNameAttribute == null || !dictionaryAttributePrefixSet)
{
prefix = attributeName + "-";
}
if (prefix != null)
{
var dictionaryValueType = dictionaryArgumentTypes[1];
var dictionaryValueTypeName = GetFullName(dictionaryValueType);
builder.AsDictionary(prefix, dictionaryValueTypeName);
}
}
var dictionaryKeyType = dictionaryArgumentTypes?[0];
if (dictionaryKeyType?.SpecialType != SpecialType.System_String)
{
if (dictionaryAttributePrefix != null)
{
// DictionaryAttributePrefix is not supported unless associated with an
// IDictionary<string, TValue> property.
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidAttributePrefixNotNull(GetFullName(containingType), property.Name);
builder.Diagnostics.Add(diagnostic);
}
return;
}
else if (!hasPublicSetter && attributeNameAttribute != null && !dictionaryAttributePrefixSet)
{
// Must set DictionaryAttributePrefix when using HtmlAttributeNameAttribute with a dictionary property
// that lacks a public setter.
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidAttributePrefixNull(GetFullName(containingType), property.Name);
builder.Diagnostics.Add(diagnostic);
return;
}
}
public override void ReportMarshalUnmanagedTypeOnlyValidForFields(DiagnosticBag diagnostics, SyntaxNode attributeSyntax, int parameterIndex, string unmanagedTypeName, AttributeData attribute)
{
var node = (AttributeSyntax)attributeSyntax;
CSharpSyntaxNode attributeArgumentSyntax = attribute.GetAttributeArgumentSyntax(parameterIndex, node);
diagnostics.Add(ErrorCode.ERR_MarshalUnmanagedTypeOnlyValidForFields, attributeArgumentSyntax.Location, unmanagedTypeName);
}
public abstract TDeclarationNode RemoveAttribute <TDeclarationNode>(
TDeclarationNode destination,
AttributeData attributeToRemove,
CodeGenerationOptions?options,
CancellationToken cancellationToken
) where TDeclarationNode : SyntaxNode;
public override bool IsApplicable(AttributeData value)
{
return(true);
}
public MultiplySuffixGenerator(AttributeData attributeData)
{
Requires.NotNull(attributeData, nameof(attributeData));
}
private static Location GetAttributeLocation(AttributeData attributeData)
{
return(attributeData.ApplicationSyntaxReference.SyntaxTree.GetLocation(attributeData.ApplicationSyntaxReference.Span));
}
private void VerifyParameterManage_EventVerifyParameter(PropertyInfo propertity, object value, AttributeData attributeBaseData, List <AttributeData> attributeDataList)
{
attributeDataList.Add(new AttributeData()
{
AttributeCode = "Name",
AttributeName = "书名",
ErrorList = new List <string>()
{
"测试1"
}
});
}
private static string?GetFirstConstructorArgumentValueOfAttribute(AttributeData data)
{
var constructorArgument = data.ConstructorArguments.First();
return((string?)constructorArgument.Value);
}
[DllImport("usdi")] public static extern IntPtr usdiTaskCreateAttrReadSample(Attribute points, ref AttributeData dst, ref double t);
/// <inheritdoc />
public CpSatParametersAssemblyCodeGenerator(AttributeData attributeData)
: base(attributeData)
{
}
public abstract void ReportMarshalUnmanagedTypeOnlyValidForFields(DiagnosticBag diagnostics, SyntaxNode attributeSyntax, int parameterIndex, string unmanagedTypeName, AttributeData attribute);
private static Location GetAttributeLocation(ref SymbolAnalysisContext symbolAnalysisContext, AttributeData attribute)
{
var syntax = attribute.ApplicationSyntaxReference.GetSyntax(symbolAnalysisContext.CancellationToken);
return(syntax?.GetLocation() ?? Location.None);
}
public override void ReportInvalidAttributeArgument(DiagnosticBag diagnostics, SyntaxNode attributeSyntax, int parameterIndex, AttributeData attribute)
{
throw new NotImplementedException();
}
public virtual async Task <IList <DtoController> > GetProjectDtoControllersWithTheirOperations(Project project, IList <Project> allSourceProjects = null)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
IList <DtoController> dtoControllers = new List <DtoController>();
foreach (Document doc in project.Documents)
{
if (!doc.SupportsSemanticModel)
{
continue;
}
SemanticModel semanticModel = await doc.GetSemanticModelAsync();
SyntaxNode root = await doc.GetSyntaxRootAsync();
List <ClassDeclarationSyntax> dtoControllersClassDecs = new List <ClassDeclarationSyntax>();
foreach (ClassDeclarationSyntax classDeclarationSyntax in root.DescendantNodes()
.OfType <ClassDeclarationSyntax>())
{
if (classDeclarationSyntax.BaseList == null)
{
continue;
}
INamedTypeSymbol controllerSymbol = (INamedTypeSymbol)semanticModel.GetDeclaredSymbol(classDeclarationSyntax);
bool isController = controllerSymbol.IsDtoController();
if (isController == true)
{
dtoControllersClassDecs.Add(classDeclarationSyntax);
}
}
if (!dtoControllersClassDecs.Any())
{
continue;
}
foreach (ClassDeclarationSyntax dtoControllerClassDec in dtoControllersClassDecs)
{
INamedTypeSymbol controllerSymbol = (INamedTypeSymbol)semanticModel.GetDeclaredSymbol(dtoControllerClassDec);
DtoController dtoController = new DtoController
{
ControllerSymbol = controllerSymbol,
Name = controllerSymbol.Name.Replace("Controller", string.Empty),
Operations = new List <ODataOperation>(),
ModelSymbol = controllerSymbol.BaseType.TypeArguments.ExtendedSingleOrDefault($"Looking for model of ${controllerSymbol.Name}", t => t.IsDto())
};
if (dtoController.ModelSymbol is ITypeParameterSymbol)
{
dtoController.ModelSymbol = ((ITypeParameterSymbol)dtoController.ModelSymbol).ConstraintTypes.ExtendedSingleOrDefault($"Looking for model on generic model {dtoController.ModelSymbol.Name}", t => t.IsDto());
}
if (dtoController.ModelSymbol == null)
{
continue;
}
dtoControllers.Add(dtoController);
if (dtoController.ControllerSymbol.IsGenericType)
{
continue;
}
foreach (MethodDeclarationSyntax methodDecSyntax in dtoControllerClassDec.DescendantNodes().OfType <MethodDeclarationSyntax>())
{
IMethodSymbol methodSymbol = (IMethodSymbol)semanticModel.GetDeclaredSymbol(methodDecSyntax);
ImmutableArray <AttributeData> attrs = methodSymbol.GetAttributes();
AttributeData actionAttribute = attrs.ExtendedSingleOrDefault($"Looking for action attribute on {methodSymbol.Name}", att => att.AttributeClass.Name == "ActionAttribute");
AttributeData functionAttribute = attrs.ExtendedSingleOrDefault($"Looking for function attribute on {methodSymbol.Name}", att => att.AttributeClass.Name == "FunctionAttribute");
if (actionAttribute == null && functionAttribute == null)
{
continue;
}
ODataOperation operation = new ODataOperation
{
Method = methodSymbol,
Kind = actionAttribute != null ? ODataOperationKind.Action : ODataOperationKind.Function,
ReturnType = methodSymbol.ReturnType
};
if (operation.Kind == ODataOperationKind.Function)
{
operation.Parameters = operation.Method.Parameters
.Where(p => p.Type.Name != "CancellationToken" && p.Type.Name != "ODataQueryOptions")
.Select(parameter => new ODataOperationParameter
{
Name = parameter.Name,
Type = parameter.Type
}).ToList();
}
else if (operation.Kind == ODataOperationKind.Action && operation.Method.Parameters.Any())
{
IParameterSymbol actionParameterContainer = operation.Method.Parameters
.Where(p => p.Type.Name != "CancellationToken" && p.Type.Name != "ODataQueryOptions")
.ExtendedSingleOrDefault($"Finding parameter of {operation.Method.ContainingType.Name}.{operation.Method.Name}. It's expected to see 0 or 1 parameter only.");
if (actionParameterContainer != null)
{
if (actionParameterContainer.Type.IsDto() || actionParameterContainer.Type.IsComplexType() || actionParameterContainer.Type.IsCollectionType())
{
operation.Parameters = new List <ODataOperationParameter>
{
new ODataOperationParameter
{
Name = actionParameterContainer.Name,
Type = actionParameterContainer.Type
}
};
}
// ToDo: else if (parameter is string or primitive or enum or date time or date time offset) { throw an exception; }
else
{
operation.Parameters = actionParameterContainer.Type.GetMembers()
.OfType <IPropertySymbol>()
.Select(prop => new ODataOperationParameter
{
Name = prop.Name,
Type = prop.Type
}).ToList();
}
}
}
dtoController.Operations.Add(operation);
}
}
}
return(dtoControllers);
}
private static AttributeSyntax GetAttributeSyntax(AttributeData attr)
{
var attrTypeName = NameVisitorCreator.GetCSharp(NameOptions.None).GetName(attr.AttributeClass);
if (attrTypeName.EndsWith(nameof(Attribute)))
{
attrTypeName = attrTypeName.Remove(attrTypeName.Length - nameof(Attribute).Length);
}
if (attr.ConstructorArguments.Length == 0 && attr.NamedArguments.Length == 0)
{
return SyntaxFactory.Attribute(SyntaxFactory.ParseName(attrTypeName));
}
return SyntaxFactory.Attribute(
SyntaxFactory.ParseName(attrTypeName),
SyntaxFactory.AttributeArgumentList(
SyntaxFactory.SeparatedList(
(from item in attr.ConstructorArguments
select GetLiteralExpression(item) into expr
where expr != null
select SyntaxFactory.AttributeArgument(expr)
).Concat(
from item in attr.NamedArguments
let expr = GetLiteralExpression(item.Value)
where expr != null
select SyntaxFactory.AttributeArgument(
SyntaxFactory.NameEquals(
SyntaxFactory.IdentifierName(item.Key)
),
null,
expr
)
)
)
)
);
}
/// <summary>
/// Initializes a new instance of the <see cref="AttributeSemantics"/> class.
/// </summary>
/// <param name="semanticObject">The Roslyn semantic object.</param>
public AttributeSemantics(AttributeData semanticObject)
: base(semanticObject)
{
}
