Improved diagnostics of error and warning locations

Author: NikolayPianikov

src/Pure.DI.Core/Core/Attributes.cs

@@ -39,15 +39,18 @@ public T GetAttribute<TMdAttribute, T>(
                     }
 
                     var args = attr.ConstructorArguments;
-                    if (attributeMetadata.ArgumentPosition >= args.Length)
+                    if (attributeMetadata.ArgumentPosition >= args.Length || args[attributeMetadata.ArgumentPosition].Kind == TypedConstantKind.Error)
                     {
                         if (attr.ApplicationSyntaxReference?.GetSyntax() is AttributeSyntax { ArgumentList: {} argumentList }
                             && attributeMetadata.ArgumentPosition < argumentList.Arguments.Count)
                         {
                             return semantic.GetConstantValue<T>(semanticModel, argumentList.Arguments[attributeMetadata.ArgumentPosition].Expression, GetSmartTagKind(kind))
                                    ?? defaultValue;
                         }
+                    }
 
+                    if (attributeMetadata.ArgumentPosition >= args.Length)
+                    {
                         throw new CompileErrorException(
                             string.Format(Strings.Error_Template_InvalidAttributeArgumentPosition, attributeMetadata.ArgumentPosition, attributeMetadata.Source, args.Length),
                             locationProvider.GetLocation(attributeMetadata.Source),

src/Pure.DI.Core/Core/Semantic.cs

@@ -116,11 +116,11 @@ when memberAccessExpressionSyntax.IsKind(SyntaxKind.SimpleMemberAccessExpression
                             return valueStr switch
                             {
                                 nameof(Tag.Type) when IsSpecialType(semanticModel, node, SpecialType.Tag) => (T)(object)Tag.Type,
-                                nameof(Tag.Unique) when IsSpecialType(semanticModel, node, SpecialType.Tag) => (T)(object)Tag.Unique,
+                                nameof(Tag.Unique) when smartTagKind == SmartTagKind.Tag && IsSpecialType(semanticModel, node, SpecialType.Tag) => (T)(object)Tag.Unique,
                                 _ => (T)smartTags.Register(SmartTagKind.Tag, valueStr)
                             };
 
-                        case nameof(Name) when typeof(T) == typeof(object):
+                        case nameof(Name) when smartTagKind == SmartTagKind.Name && typeof(T) == typeof(object):
                             return (T)smartTags.Register(SmartTagKind.Name, valueStr);
                     }
                 }