Add RequiredArguments to IAnnotation

MDoerner · MDoerner · commit 9fed0b3c7244 · 2020-02-27T22:04:19.000+01:00
It specifies the minimal number of arguments for the annotation.
diff --git a/Rubberduck.Parsing/Annotations/AnnotationBase.cs b/Rubberduck.Parsing/Annotations/AnnotationBase.cs
@@ -6,14 +6,16 @@ namespace Rubberduck.Parsing.Annotations
     public abstract class AnnotationBase : IAnnotation
     {
         public bool AllowMultiple { get; }
+        public int RequiredArguments { get; }
         public string Name { get; }
         public AnnotationTarget Target { get; }
 
-        protected AnnotationBase(string name, AnnotationTarget target, bool allowMultiple = false)
+        protected AnnotationBase(string name, AnnotationTarget target, int requiredArguments = 0, bool allowMultiple = false)
         {
             Name = name;
             Target = target;
             AllowMultiple = allowMultiple;
+            RequiredArguments = requiredArguments;
         }
 
         public virtual IReadOnlyList<string> ProcessAnnotationArguments(IEnumerable<string> arguments)
diff --git a/Rubberduck.Parsing/Annotations/Concrete/FixedAttributeValueAnnotationBase.cs b/Rubberduck.Parsing/Annotations/Concrete/FixedAttributeValueAnnotationBase.cs
@@ -1,32 +1,29 @@
-﻿using System;
-using System.Collections.Generic;
+﻿using System.Collections.Generic;
 using System.Linq;
-using Rubberduck.Parsing.Grammar;
-using Rubberduck.VBEditor;
 
 namespace Rubberduck.Parsing.Annotations
 {
     public abstract class FixedAttributeValueAnnotationBase : AnnotationBase, IAttributeAnnotation
     {
-        private readonly string attribute;
-        private readonly IReadOnlyList<string> attributeValues;
+        private readonly string _attribute;
+        private readonly IReadOnlyList<string> _attributeValues;
 
         protected FixedAttributeValueAnnotationBase(string name, AnnotationTarget target, string attribute, IEnumerable<string> attributeValues, bool allowMultiple = false)
-            : base(name, target, allowMultiple)
+            : base(name, target, allowMultiple: allowMultiple)
         {
             // IEnumerable makes specifying the compile-time constant list easier on us
-            this.attributeValues = attributeValues.ToList();
-            this.attribute = attribute;
+            _attributeValues = attributeValues.ToList();
+            _attribute = attribute;
         }
 
         public IReadOnlyList<string> AnnotationToAttributeValues(IReadOnlyList<string> annotationValues)
         {
-            return attributeValues;
+            return _attributeValues;
         }
 
         public string Attribute(IReadOnlyList<string> annotationValues)
         {
-            return attribute;
+            return _attribute;
         }
 
         public IReadOnlyList<string> AttributeToAnnotationValues(IReadOnlyList<string> attributeValues)
@@ -37,7 +34,7 @@ public IReadOnlyList<string> AttributeToAnnotationValues(IReadOnlyList<string> a
 
         public bool MatchesAttributeDefinition(string attributeName, IReadOnlyList<string> attributeValues)
         {
-            return attribute == attributeName && this.attributeValues.SequenceEqual(attributeValues);
+            return _attribute == attributeName && this._attributeValues.SequenceEqual(attributeValues);
         }
     }
 }
diff --git a/Rubberduck.Parsing/Annotations/Concrete/FlexibleAttributeAnnotationBase.cs b/Rubberduck.Parsing/Annotations/Concrete/FlexibleAttributeAnnotationBase.cs
@@ -1,16 +1,14 @@
 ﻿using System.Collections.Generic;
 using System.Linq;
 using Rubberduck.Common;
-using Rubberduck.Parsing.Grammar;
-using Rubberduck.VBEditor;
 
 namespace Rubberduck.Parsing.Annotations
 {
     public abstract class FlexibleAttributeAnnotationBase : AnnotationBase, IAttributeAnnotation
     {
         protected FlexibleAttributeAnnotationBase(string name, AnnotationTarget target, bool allowMultiple = false)
-            : base(name, target, allowMultiple)
-        { }
+            : base(name, target, 2, allowMultiple) //We need at least the attribute name and one value for it.
+        {}
         
         public IReadOnlyList<string> AnnotationToAttributeValues(IReadOnlyList<string> annotationValues)
         {
diff --git a/Rubberduck.Parsing/Annotations/Concrete/FlexibleAttributeValueAnnotationBase.cs b/Rubberduck.Parsing/Annotations/Concrete/FlexibleAttributeValueAnnotationBase.cs
@@ -2,8 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using Rubberduck.Common;
-using Rubberduck.Parsing.Grammar;
-using Rubberduck.VBEditor;
 
 namespace Rubberduck.Parsing.Annotations
 {
@@ -13,7 +11,7 @@ public abstract class FlexibleAttributeValueAnnotationBase : AnnotationBase, IAt
         private readonly int _numberOfValues;
 
         protected FlexibleAttributeValueAnnotationBase(string name, AnnotationTarget target, string attribute, int numberOfValues)
-            : base(name, target)
+            : base(name, target, numberOfValues)
         {
             _attribute = attribute;
             _numberOfValues = numberOfValues;
diff --git a/Rubberduck.Parsing/Annotations/Concrete/FolderAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/FolderAnnotation.cs
@@ -1,17 +1,12 @@
-﻿using Rubberduck.VBEditor;
-using System.Collections.Generic;
-using System.Linq;
-using Rubberduck.Parsing.Grammar;
-
-namespace Rubberduck.Parsing.Annotations
+﻿namespace Rubberduck.Parsing.Annotations
 {
     /// <summary>
     /// Used for specifying the Code Explorer folder a appears under.
     /// </summary>
     public sealed class FolderAnnotation : AnnotationBase
     {
         public FolderAnnotation()
-            : base("Folder", AnnotationTarget.Module)
-        { }
+            : base("Folder", AnnotationTarget.Module, 1)
+        {}
     }
 }
diff --git a/Rubberduck.Parsing/Annotations/Concrete/IgnoreAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/IgnoreAnnotation.cs
@@ -1,17 +1,12 @@
-﻿using Rubberduck.VBEditor;
-using System.Collections.Generic;
-using System.Linq;
-using Rubberduck.Parsing.Grammar;
-
-namespace Rubberduck.Parsing.Annotations
+﻿namespace Rubberduck.Parsing.Annotations
 {
     /// <summary>
     /// Used for ignoring specific inspection results from a specified set of inspections.
     /// </summary>
     public sealed class IgnoreAnnotation : AnnotationBase
     {
         public IgnoreAnnotation()
-            : base("Ignore", AnnotationTarget.General, true)
-        { }
+            : base("Ignore", AnnotationTarget.General, 1, true)
+        {}
     }
 }
diff --git a/Rubberduck.Parsing/Annotations/Concrete/IgnoreModuleAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/IgnoreModuleAnnotation.cs
@@ -1,17 +1,12 @@
-﻿using System.Collections.Generic;
-using System.Linq;
-using Rubberduck.Parsing.Grammar;
-using Rubberduck.VBEditor;
-
-namespace Rubberduck.Parsing.Annotations
+﻿namespace Rubberduck.Parsing.Annotations
 {
     /// <summary>
     /// This annotation allows ignoring inspection results of defined inspections for a whole module
     /// </summary>
     public sealed class IgnoreModuleAnnotation : AnnotationBase
     {
         public IgnoreModuleAnnotation()
-            : base("IgnoreModule", AnnotationTarget.Module, true)
-        { }
+            : base("IgnoreModule", AnnotationTarget.Module, 1, true)
+        {}
     }
 }
diff --git a/Rubberduck.Parsing/Annotations/Concrete/IgnoreTestAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/IgnoreTestAnnotation.cs
@@ -1,8 +1,4 @@
-﻿using System.Collections.Generic;
-using Rubberduck.Parsing.Grammar;
-using Rubberduck.VBEditor;
-
-namespace Rubberduck.Parsing.Annotations
+﻿namespace Rubberduck.Parsing.Annotations
 {
     /// <summary>
     /// Used to indicate the test engine that a unit test is to be ignored.
diff --git a/Rubberduck.Parsing/Annotations/Concrete/InterfaceAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/InterfaceAnnotation.cs
@@ -7,6 +7,6 @@ public sealed class InterfaceAnnotation : AnnotationBase
     {
         public InterfaceAnnotation()
             : base("Interface", AnnotationTarget.Module)
-        { }
+        {}
     }
 }
diff --git a/Rubberduck.Parsing/Annotations/Concrete/ModuleCleanupAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/ModuleCleanupAnnotation.cs
@@ -1,8 +1,4 @@
-﻿using Rubberduck.VBEditor;
-using System.Collections.Generic;
-using Rubberduck.Parsing.Grammar;
-
-namespace Rubberduck.Parsing.Annotations
+﻿namespace Rubberduck.Parsing.Annotations
 {
     /// <summary>
     /// Marks a method that the test engine will execute after all unit tests in a test module have executed.
@@ -11,6 +7,6 @@ public sealed class ModuleCleanupAnnotation : AnnotationBase, ITestAnnotation
     {
         public ModuleCleanupAnnotation()
             : base("ModuleCleanup", AnnotationTarget.Member)
-        { }
+        {}
     }
 }
diff --git a/Rubberduck.Parsing/Annotations/Concrete/ModuleInitializeAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/ModuleInitializeAnnotation.cs
@@ -1,8 +1,4 @@
-﻿using Rubberduck.VBEditor;
-using System.Collections.Generic;
-using Rubberduck.Parsing.Grammar;
-
-namespace Rubberduck.Parsing.Annotations
+﻿namespace Rubberduck.Parsing.Annotations
 {
     /// <summary>
     /// Marks a method that the test engine will execute before executing the first unit test in a test module.
@@ -11,6 +7,6 @@ public sealed class ModuleInitializeAnnotation : AnnotationBase, ITestAnnotation
     {
         public ModuleInitializeAnnotation()
             : base("ModuleInitialize", AnnotationTarget.Member)
-        { }
+        {}
     }
 }
diff --git a/Rubberduck.Parsing/Annotations/Concrete/NoIndentAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/NoIndentAnnotation.cs
@@ -7,6 +7,6 @@ public sealed class NoIndentAnnotation : AnnotationBase
     {
         public NoIndentAnnotation()
             : base("NoIndent", AnnotationTarget.Module)
-        { }
+        {}
     }
 }
diff --git a/Rubberduck.Parsing/Annotations/Concrete/NotRecognizedAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/NotRecognizedAnnotation.cs
@@ -1,8 +1,4 @@
-﻿using Rubberduck.VBEditor;
-using System.Collections.Generic;
-using Rubberduck.Parsing.Grammar;
-
-namespace Rubberduck.Parsing.Annotations
+﻿namespace Rubberduck.Parsing.Annotations
 {
     /// <summary>
     /// Used for all annotations not recognized by RD.
@@ -12,6 +8,6 @@ public sealed class NotRecognizedAnnotation : AnnotationBase
     {
         public NotRecognizedAnnotation()
             : base("NotRecognized", 0)
-        { }
+        {}
     }
 }
diff --git a/Rubberduck.Parsing/Annotations/Concrete/ObsoleteAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/ObsoleteAnnotation.cs
@@ -1,7 +1,5 @@
 ﻿using System.Collections.Generic;
 using System.Linq;
-using Rubberduck.Parsing.Grammar;
-using Rubberduck.VBEditor;
 
 namespace Rubberduck.Parsing.Annotations
 {
@@ -10,12 +8,21 @@ namespace Rubberduck.Parsing.Annotations
     /// </summary>
     public sealed class ObsoleteAnnotation : AnnotationBase
     {
-        public string ReplacementDocumentation { get; }
+        public string ReplacementDocumentation { get; private set; }
 
         public ObsoleteAnnotation()
             : base("Obsolete", AnnotationTarget.Member | AnnotationTarget.Variable)
-        { }
+        {}
 
-        // FIXME correctly handle the fact that the replacement documentation is only the first parameter!
+        public override IReadOnlyList<string> ProcessAnnotationArguments(IEnumerable<string> arguments)
+        {
+            var args = arguments.ToList();
+
+            ReplacementDocumentation = args.Any()
+                ? args[0]
+                : string.Empty;
+
+            return base.ProcessAnnotationArguments(args);
+        }
     }
 }
diff --git a/Rubberduck.Parsing/Annotations/Concrete/TestCleanupAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/TestCleanupAnnotation.cs
@@ -1,8 +1,4 @@
-﻿using Rubberduck.VBEditor;
-using System.Collections.Generic;
-using Rubberduck.Parsing.Grammar;
-
-namespace Rubberduck.Parsing.Annotations
+﻿namespace Rubberduck.Parsing.Annotations
 {
     /// <summary>
     /// Marks a method that the test engine will execute after executing each unit test in a test module.
@@ -11,7 +7,6 @@ public sealed class TestCleanupAnnotation : AnnotationBase, ITestAnnotation
     {
         public TestCleanupAnnotation()
             : base("TestCleanup", AnnotationTarget.Member)
-        {
-        }
+        {}
     }
 }
diff --git a/Rubberduck.Parsing/Annotations/Concrete/TestInitializeAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/TestInitializeAnnotation.cs
@@ -1,8 +1,4 @@
-﻿using Rubberduck.VBEditor;
-using System.Collections.Generic;
-using Rubberduck.Parsing.Grammar;
-
-namespace Rubberduck.Parsing.Annotations
+﻿namespace Rubberduck.Parsing.Annotations
 {
     /// <summary>
     /// Marks a method that the test engine will execute before executing each unit test in a test module.
diff --git a/Rubberduck.Parsing/Annotations/Concrete/TestMethodAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/TestMethodAnnotation.cs
@@ -1,8 +1,5 @@
-﻿using System;
-using Rubberduck.VBEditor;
-using System.Collections.Generic;
+﻿using System.Collections.Generic;
 using System.Linq;
-using Rubberduck.Parsing.Grammar;
 using Rubberduck.Common;
 
 namespace Rubberduck.Parsing.Annotations
@@ -14,7 +11,7 @@ public sealed class TestMethodAnnotation : AnnotationBase, ITestAnnotation
     {
         public TestMethodAnnotation()
             : base("TestMethod", AnnotationTarget.Member)
-        {  }
+        {}
 
         public IReadOnlyList<string> ProcessAnnotationArguments(IEnumerable<string> arguments)
         {
diff --git a/Rubberduck.Parsing/Annotations/Concrete/TestModuleAnnotation.cs b/Rubberduck.Parsing/Annotations/Concrete/TestModuleAnnotation.cs
@@ -1,8 +1,4 @@
-﻿using Rubberduck.VBEditor;
-using System.Collections.Generic;
-using Rubberduck.Parsing.Grammar;
-
-namespace Rubberduck.Parsing.Annotations
+﻿namespace Rubberduck.Parsing.Annotations
 {
     /// <summary>
     /// Marks a module that the test engine treat as a test module.
@@ -14,6 +10,6 @@ public sealed class TestModuleAnnotation : AnnotationBase
     {
         public TestModuleAnnotation()
             : base("TestModule", AnnotationTarget.Module)
-        { }
+        {}
     }
 }
diff --git a/Rubberduck.Parsing/Annotations/IAnnotation.cs b/Rubberduck.Parsing/Annotations/IAnnotation.cs
@@ -6,9 +6,22 @@ namespace Rubberduck.Parsing.Annotations
     public interface IAnnotation
     {
         string Name { get; }
+
+        /// <summary>
+        /// The kind of object this annotation can be applied to 
+        /// </summary>
         AnnotationTarget Target { get; }
+
+        /// <summary>
+        /// Specifies whether there can be multiple instances of the annotation on the same target.
+        /// </summary>
         bool AllowMultiple { get; }
 
+        /// <summary>
+        /// The minimal number of arguments that must be provided to for this annotation
+        /// </summary>
+        int RequiredArguments { get; }
+
         IReadOnlyList<string> ProcessAnnotationArguments(IEnumerable<string> arguments);
     }
 
diff --git a/Rubberduck.Parsing/Annotations/ParseTreeAnnotation.cs b/Rubberduck.Parsing/Annotations/ParseTreeAnnotation.cs
@@ -3,8 +3,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Rubberduck.Parsing.Annotations
 {

Original file line number	Diff line number	Diff line change
`@@ -6,14 +6,16 @@ namespace Rubberduck.Parsing.Annotations`
`6`	`6`	`public abstract class AnnotationBase : IAnnotation`
`7`	`7`	`{`
`8`	`8`	`public bool AllowMultiple { get; }`
	`9`	`+ public int RequiredArguments { get; }`
`9`	`10`	`public string Name { get; }`
`10`	`11`	`public AnnotationTarget Target { get; }`
`11`	`12`
`12`		`- protected AnnotationBase(string name, AnnotationTarget target, bool allowMultiple = false)`
	`13`	`+ protected AnnotationBase(string name, AnnotationTarget target, int requiredArguments = 0, bool allowMultiple = false)`
`13`	`14`	`{`
`14`	`15`	`Name = name;`
`15`	`16`	`Target = target;`
`16`	`17`	`AllowMultiple = allowMultiple;`
	`18`	`+ RequiredArguments = requiredArguments;`
`17`	`19`	`}`
`18`	`20`
`19`	`21`	`public virtual IReadOnlyList<string> ProcessAnnotationArguments(IEnumerable<string> arguments)`
Original file line number	Diff line number	Diff line change
`@@ -1,32 +1,29 @@`
`1`		`-using System;`
`2`		`-using System.Collections.Generic;`
	`1`	`+using System.Collections.Generic;`
`3`	`2`	`using System.Linq;`
`4`		`-using Rubberduck.Parsing.Grammar;`
`5`		`-using Rubberduck.VBEditor;`
`6`	`3`
`7`	`4`	`namespace Rubberduck.Parsing.Annotations`
`8`	`5`	`{`
`9`	`6`	`public abstract class FixedAttributeValueAnnotationBase : AnnotationBase, IAttributeAnnotation`
`10`	`7`	`{`
`11`		`- private readonly string attribute;`
`12`		`- private readonly IReadOnlyList<string> attributeValues;`
	`8`	`+ private readonly string _attribute;`
	`9`	`+ private readonly IReadOnlyList<string> _attributeValues;`
`13`	`10`
`14`	`11`	`protected FixedAttributeValueAnnotationBase(string name, AnnotationTarget target, string attribute, IEnumerable<string> attributeValues, bool allowMultiple = false)`
`15`		`- : base(name, target, allowMultiple)`
	`12`	`+ : base(name, target, allowMultiple: allowMultiple)`
`16`	`13`	`{`
`17`	`14`	`// IEnumerable makes specifying the compile-time constant list easier on us`
`18`		`- this.attributeValues = attributeValues.ToList();`
`19`		`- this.attribute = attribute;`
	`15`	`+ _attributeValues = attributeValues.ToList();`
	`16`	`+ _attribute = attribute;`
`20`	`17`	`}`
`21`	`18`
`22`	`19`	`public IReadOnlyList<string> AnnotationToAttributeValues(IReadOnlyList<string> annotationValues)`
`23`	`20`	`{`
`24`		`- return attributeValues;`
	`21`	`+ return _attributeValues;`
`25`	`22`	`}`
`26`	`23`
`27`	`24`	`public string Attribute(IReadOnlyList<string> annotationValues)`
`28`	`25`	`{`
`29`		`- return attribute;`
	`26`	`+ return _attribute;`
`30`	`27`	`}`
`31`	`28`
`32`	`29`	`public IReadOnlyList<string> AttributeToAnnotationValues(IReadOnlyList<string> attributeValues)`
`@@ -37,7 +34,7 @@ public IReadOnlyList<string> AttributeToAnnotationValues(IReadOnlyList<string> a`
`37`	`34`
`38`	`35`	`public bool MatchesAttributeDefinition(string attributeName, IReadOnlyList<string> attributeValues)`
`39`	`36`	`{`
`40`		`- return attribute == attributeName && this.attributeValues.SequenceEqual(attributeValues);`
	`37`	`+ return _attribute == attributeName && this._attributeValues.SequenceEqual(attributeValues);`
`41`	`38`	`}`
`42`	`39`	`}`
`43`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,16 +1,14 @@`
`1`	`1`	`using System.Collections.Generic;`
`2`	`2`	`using System.Linq;`
`3`	`3`	`using Rubberduck.Common;`
`4`		`-using Rubberduck.Parsing.Grammar;`
`5`		`-using Rubberduck.VBEditor;`
`6`	`4`
`7`	`5`	`namespace Rubberduck.Parsing.Annotations`
`8`	`6`	`{`
`9`	`7`	`public abstract class FlexibleAttributeAnnotationBase : AnnotationBase, IAttributeAnnotation`
`10`	`8`	`{`
`11`	`9`	`protected FlexibleAttributeAnnotationBase(string name, AnnotationTarget target, bool allowMultiple = false)`
`12`		`- : base(name, target, allowMultiple)`
`13`		`- { }`
	`10`	`+ : base(name, target, 2, allowMultiple) //We need at least the attribute name and one value for it.`
	`11`	`+ {}`
`14`	`12`
`15`	`13`	`public IReadOnlyList<string> AnnotationToAttributeValues(IReadOnlyList<string> annotationValues)`
`16`	`14`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,12 @@`
`1`		`-using Rubberduck.VBEditor;`
`2`		`-using System.Collections.Generic;`
`3`		`-using System.Linq;`
`4`		`-using Rubberduck.Parsing.Grammar;`
`5`		`-`
`6`		`-namespace Rubberduck.Parsing.Annotations`
	`1`	`+namespace Rubberduck.Parsing.Annotations`
`7`	`2`	`{`
`8`	`3`	`/// <summary>`
`9`	`4`	`/// Used for specifying the Code Explorer folder a appears under.`
`10`	`5`	`/// </summary>`
`11`	`6`	`public sealed class FolderAnnotation : AnnotationBase`
`12`	`7`	`{`
`13`	`8`	`public FolderAnnotation()`
`14`		`- : base("Folder", AnnotationTarget.Module)`
`15`		`- { }`
	`9`	`+ : base("Folder", AnnotationTarget.Module, 1)`
	`10`	`+ {}`
`16`	`11`	`}`
`17`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,6 @@ public sealed class InterfaceAnnotation : AnnotationBase`
`7`	`7`	`{`
`8`	`8`	`public InterfaceAnnotation()`
`9`	`9`	`: base("Interface", AnnotationTarget.Module)`
`10`		`- { }`
	`10`	`+ {}`
`11`	`11`	`}`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,4 @@`
`1`		`-using Rubberduck.VBEditor;`
`2`		`-using System.Collections.Generic;`
`3`		`-using Rubberduck.Parsing.Grammar;`
`4`		`-`
`5`		`-namespace Rubberduck.Parsing.Annotations`
	`1`	`+namespace Rubberduck.Parsing.Annotations`
`6`	`2`	`{`
`7`	`3`	`/// <summary>`
`8`	`4`	`/// Marks a method that the test engine will execute after all unit tests in a test module have executed.`
`@@ -11,6 +7,6 @@ public sealed class ModuleCleanupAnnotation : AnnotationBase, ITestAnnotation`
`11`	`7`	`{`
`12`	`8`	`public ModuleCleanupAnnotation()`
`13`	`9`	`: base("ModuleCleanup", AnnotationTarget.Member)`
`14`		`- { }`
	`10`	`+ {}`
`15`	`11`	`}`
`16`	`12`	`}`