Update asmdef files when project references are added/removed

CHANGELOG.md

@@ -14,6 +14,7 @@ Since 2018.1, the version numbers and release cycle match Rider's versions and r
 
 ### Added
 
+- Add and remove references to `.asmdef` files when project references are modified, including with Remove Unused References refactoring ([#852](https://github.com/JetBrains/resharper-unity/issues/852), [RIDER-48660](https://youtrack.jetbrains.com/issue/RIDER-48660), [#1994](https://github.com/JetBrains/resharper-unity/issues/1994), [#2279](https://github.com/JetBrains/resharper-unity/pull/2279))
 - Add support for `.asmref` files ([#1406](https://github.com/JetBrains/resharper-unity/issues/1406), [#2252](https://github.com/JetBrains/resharper-unity/pull/2252))
 - Add inspection for correct method signature for `MenuItem` attribute ([RIDER-69350](https://youtrack.jetbrains.com/issue/RIDER-69350), [#2266](https://github.com/JetBrains/resharper-unity/pull/2266))
 - Rider: Add new run configuration to run Unity tests in batch mode ([RIDER-70675](https://youtrack.jetbrains.com/issue/RIDER-70675), [#2231](https://github.com/JetBrains/resharper-unity/pull/2231))
@@ -23,6 +24,7 @@ Since 2018.1, the version numbers and release cycle match Rider's versions and r
 
 - Show preview for target typed new instances of `Color` ([RIDER-64151](https://youtrack.jetbrains.com/issue/RIDER-64151), [#2250](https://github.com/JetBrains/resharper-unity/pull/2250))
 - Update API information to 2022.1.0b7 ([#2276](https://github.com/JetBrains/resharper-unity/pull/2276))
+- Rider: Hide rename solution and manage NuGet packages by default ([RIDER-62297](https://youtrack.jetbrains.com/issue/RIDER-62297), [#2277](https://github.com/JetBrains/resharper-unity/pull/2277))
 - Unity editor: Expand Find Usages editor window by default ([#2239](https://github.com/JetBrains/resharper-unity/pull/2239))
 
 ### Fixed
@@ -42,7 +44,7 @@ Since 2018.1, the version numbers and release cycle match Rider's versions and r
 - Rider: Fix display of unprintable characters in console output when debugging batchmode tests ([RIDER-74056](https://youtrack.jetbrains.com/issue/RIDER-74056), [#2265](https://github.com/JetBrains/resharper-unity/pull/2265))
 - Rider: Fix performance issue displaying long log issues from Unity ([RIDER-70574](https://youtrack.jetbrains.com/issue/RIDER-70574), [#2270](https://github.com/JetBrains/resharper-unity/pull/2270))
 - Rider: Fix showing duplicate project names in Unity Explorer under certain circumstances ([RIDER-67457](https://youtrack.jetbrains.com/issue/RIDER-67457), [#2273](https://github.com/JetBrains/resharper-unity/pull/2273))
-- Rider: Fix root folder of an external package ignoring namespace provider setting ([RIDER-65100](https://youtrack.jetbrains.com/issue/RIDER-65100), [#2274)(https://github.com/JetBrains/resharper-unity/pull/2274))
+- Rider: Fix root folder of an external package ignoring namespace provider setting ([RIDER-65100](https://youtrack.jetbrains.com/issue/RIDER-65100), [#2274](https://github.com/JetBrains/resharper-unity/pull/2274))
 
 
 

resharper/resharper-json/src/Json/Psi/JsonNewElementFactory.cs

@@ -1,48 +1,53 @@
-using JetBrains.Annotations;
-using JetBrains.ProjectModel;
+using JetBrains.Diagnostics;
 using JetBrains.ReSharper.Plugins.Json.Psi.Parsing;
 using JetBrains.ReSharper.Plugins.Json.Psi.Tree;
 using JetBrains.ReSharper.Psi;
 using JetBrains.ReSharper.Psi.ExtensionsAPI.Tree;
 using JetBrains.ReSharper.Psi.Modules;
 using JetBrains.Text;
 
+#nullable enable
+
 namespace JetBrains.ReSharper.Plugins.Json.Psi
 {
     public class JsonNewElementFactory
     {
-        [NotNull] private readonly IPsiModule myModule;
-        [NotNull] private readonly ISolution mySolution;
-        [NotNull] private readonly PsiLanguageType myLanguage;
-        [NotNull]private readonly LanguageService myLanguageService;
+        private readonly IPsiModule myModule;
+        private readonly LanguageService myLanguageService;
 
-        public static JsonNewElementFactory GetInstance(IPsiModule psiModule)
-        {
-            return new JsonNewElementFactory(psiModule, psiModule.GetSolution(), JsonNewLanguage.Instance);
-        }
+        public static JsonNewElementFactory GetInstance(IPsiModule psiModule) => new(psiModule,
+            JsonNewLanguage.Instance.NotNull());
 
-        private JsonNewElementFactory([NotNull] IPsiModule module, [NotNull] ISolution solution, [NotNull] PsiLanguageType language)
+        private JsonNewElementFactory(IPsiModule module, PsiLanguageType language)
         {
             myModule = module;
-            mySolution = solution;
-            myLanguage = language;
-            myLanguageService = language.LanguageService();
+            myLanguageService = language.LanguageService().NotNull();
         }
 
         private JsonNewParser CreateParser(string text)
         {
             var lexerFactory = myLanguageService.GetPrimaryLexerFactory();
             var lexer = lexerFactory.CreateLexer(new StringBuffer(text));
 
-            return myLanguageService.CreateParser(lexer, myModule, null) as JsonNewParser;
+            return (JsonNewParser)myLanguageService.CreateParser(lexer, myModule, null);
         }
 
         public IJsonNewLiteralExpression CreateStringLiteral(string literal)
         {
             var parser = CreateParser($"\"{literal}\"");
             var node = parser.ParseLiteral();
             if (node == null)
-                throw new ElementFactoryException(string.Format("Cannot create expression '{0}'", literal));
+                throw new ElementFactoryException($"Cannot create expression \"{literal}\"");
+            SandBox.CreateSandBoxFor(node, myModule, myLanguageService.LanguageType);
+            return node;
+        }
+
+        public IJsonNewValue CreateValue(string value)
+        {
+            var parser = CreateParser(value);
+            var node = parser.ParseValue();
+            if (node == null)
+                throw new ElementFactoryException($"Cannot create expression '{value}'");
             SandBox.CreateSandBoxFor(node, myModule, myLanguageService.LanguageType);
             return node;
         }

resharper/resharper-json/src/Json/Psi/Parsing/JsonNew.psi

@@ -57,16 +57,16 @@ options {
 
 errorhandling jsonNewObject
 :
-  LBRACE
+  LBRACE<LBRACE, LBrace>
   LIST (jsonNewMember<MEMBER, Members>?) SEP COMMA
-  RBRACE
+  RBRACE<RBRACE, RBrace>
 ;
 
 errorhandling jsonNewArray
 :
-  LBRACKET
+  LBRACKET<LBRACKET, LBracket>
   LIST (jsonNewValue<VALUE, Values>?) SEP COMMA
-  RBRACKET
+  RBRACKET<RBRACKET, RBracket>
 ;
 
 errorhandling jsonNewMember

resharper/resharper-json/src/Json/Psi/Parsing/JsonNewParser.cs

@@ -31,6 +31,16 @@ private JsonNewTreeBuilder CreateTreeBuilder(Lifetime lifetime)
             return new JsonNewTreeBuilder(myLexer, lifetime);
         }
 
+        public IJsonNewValue ParseValue()
+        {
+            return Lifetime.Using(lifetime =>
+            {
+                var builder = CreateTreeBuilder(lifetime);
+                builder.ParseJsonValue();
+                return (IJsonNewValue) builder.GetTree();
+            });
+        }
+
         public IJsonNewLiteralExpression ParseLiteral()
         {
             return Lifetime.Using(lifetime =>

resharper/resharper-json/src/Json/Psi/Tree/IJsonNewArray.cs

@@ -1,7 +1,11 @@
+#nullable enable
+
 namespace JetBrains.ReSharper.Plugins.Json.Psi.Tree
 {
     public partial interface IJsonNewArray
     {
+        void AddArrayElementBefore(IJsonNewValue value, IJsonNewValue? anchor);
+        void AddArrayElementAfter(IJsonNewValue value, IJsonNewValue? anchor);
         void RemoveArrayElement(IJsonNewValue argument);
     }
 }

resharper/resharper-json/src/Json/Psi/Tree/IJsonNewObject.cs

@@ -0,0 +1,10 @@
+#nullable enable
+
+namespace JetBrains.ReSharper.Plugins.Json.Psi.Tree
+{
+    public partial interface IJsonNewObject
+    {
+        IJsonNewMember AddMemberBefore(string key, IJsonNewValue value, IJsonNewMember? anchor);
+        IJsonNewMember AddMemberAfter(string key, IJsonNewValue value, IJsonNewMember? anchor);
+    }
+}

resharper/resharper-json/src/Json/Psi/Tree/Impl/JsonNewArray.cs

@@ -1,14 +1,79 @@
-using JetBrains.Annotations;
+using JetBrains.Diagnostics;
 using JetBrains.ReSharper.Plugins.Json.Psi.Parsing.TokenNodeTypes;
+using JetBrains.ReSharper.Psi.ExtensionsAPI;
 using JetBrains.ReSharper.Psi.ExtensionsAPI.Tree;
 using JetBrains.ReSharper.Psi.Tree;
 using JetBrains.ReSharper.Resources.Shell;
 
+#nullable enable
+
 namespace JetBrains.ReSharper.Plugins.Json.Psi.Tree.Impl
 {
     internal partial class JsonNewArray
     {
-        public void RemoveArrayElement([NotNull] IJsonNewValue argument)
+        public void AddArrayElementBefore(IJsonNewValue value, IJsonNewValue? anchor)
+        {
+            if (anchor == null)
+            {
+                var lastItem = Values.LastOrDefault();
+                if (lastItem != null)
+                {
+                    AddArrayElementAfter(value, lastItem);
+                    return;
+                }
+
+                using (WriteLockCookie.Create(parent.IsPhysical()))
+                {
+                    if (RBracket != null)
+                        ModificationUtil.AddChildBefore(RBracket, value);
+                    else if (LBracket != null)
+                        ModificationUtil.AddChildAfter(LBracket, value);
+                }
+            }
+            else
+            {
+                Assertion.Assert(Values.Contains(anchor));
+                using (WriteLockCookie.Create(parent.IsPhysical()))
+                {
+                    var comma = JsonNewTokenNodeTypes.COMMA.CreateLeafElement();
+                    LowLevelModificationUtil.AddChildBefore(anchor, comma);
+                    ModificationUtil.AddChildBefore(comma, value);
+                }
+            }
+        }
+
+        public void AddArrayElementAfter(IJsonNewValue value, IJsonNewValue? anchor)
+        {
+            if (anchor == null)
+            {
+                var firstItem = ValuesEnumerable.FirstOrDefault();
+                if (firstItem != null)
+                {
+                    AddArrayElementBefore(value, firstItem);
+                    return;
+                }
+
+                using (WriteLockCookie.Create(parent.IsPhysical()))
+                {
+                    if (RBracket != null)
+                        ModificationUtil.AddChildBefore(RBracket, value);
+                    else if (LBracket != null)
+                        ModificationUtil.AddChildAfter(LBracket, value);
+                }
+            }
+            else
+            {
+                Assertion.Assert(Values.Contains(anchor));
+                using (WriteLockCookie.Create(parent.IsPhysical()))
+                {
+                    var comma = JsonNewTokenNodeTypes.COMMA.CreateLeafElement();
+                    LowLevelModificationUtil.AddChildAfter(anchor, comma);
+                    ModificationUtil.AddChildAfter(comma, value);
+                }
+            }
+        }
+
+        public void RemoveArrayElement(IJsonNewValue argument)
         {
             using (WriteLockCookie.Create(IsPhysical()))
             {

resharper/resharper-json/src/Json/Psi/Tree/Impl/JsonNewObject.cs

@@ -0,0 +1,82 @@
+using JetBrains.Diagnostics;
+using JetBrains.ReSharper.Plugins.Json.Psi.Parsing.TokenNodeTypes;
+using JetBrains.ReSharper.Psi.ExtensionsAPI;
+using JetBrains.ReSharper.Psi.ExtensionsAPI.Tree;
+using JetBrains.ReSharper.Resources.Shell;
+
+#nullable enable
+
+namespace JetBrains.ReSharper.Plugins.Json.Psi.Tree.Impl
+{
+    internal partial class JsonNewObject
+    {
+        public IJsonNewMember AddMemberBefore(string key, IJsonNewValue value, IJsonNewMember? anchor)
+        {
+            if (anchor == null)
+            {
+                var lastItem = Members.LastOrDefault();
+                if (lastItem != null)
+                    return AddMemberAfter(key, value, lastItem);
+
+                using (WriteLockCookie.Create(parent.IsPhysical()))
+                {
+                    var member = CreateMember(key, value);
+                    if (RBrace != null)
+                        ModificationUtil.AddChildBefore(RBrace, member);
+                    else if (LBrace != null)
+                        ModificationUtil.AddChildAfter(LBrace, member);
+                    return member;
+                }
+            }
+
+            Assertion.Assert(Members.Contains(anchor));
+            using (WriteLockCookie.Create(parent.IsPhysical()))
+            {
+                var member = CreateMember(key, value);
+                var comma = JsonNewTokenNodeTypes.COMMA.CreateLeafElement();
+                LowLevelModificationUtil.AddChildBefore(anchor, comma);
+                ModificationUtil.AddChildBefore(comma, member);
+                return member;
+            }
+        }
+
+        public IJsonNewMember AddMemberAfter(string key, IJsonNewValue value, IJsonNewMember? anchor)
+        {
+            if (anchor == null)
+            {
+                var firstItem = MembersEnumerable.FirstOrDefault();
+                if (firstItem != null)
+                    return AddMemberBefore(key, value, firstItem);
+
+                using (WriteLockCookie.Create(parent.IsPhysical()))
+                {
+                    var member = CreateMember(key, value);
+                    if (RBrace != null)
+                        ModificationUtil.AddChildBefore(RBrace, member);
+                    else if (LBrace != null)
+                        ModificationUtil.AddChildAfter(LBrace, member);
+                    return member;
+                }
+            }
+
+            Assertion.Assert(Members.Contains(anchor));
+            using (WriteLockCookie.Create(parent.IsPhysical()))
+            {
+                var member = CreateMember(key, value);
+                var comma = JsonNewTokenNodeTypes.COMMA.CreateLeafElement();
+                LowLevelModificationUtil.AddChildAfter(anchor, comma);
+                ModificationUtil.AddChildAfter(comma, member);
+                return member;
+            }
+        }
+
+        private static IJsonNewMember CreateMember(string key, IJsonNewValue value)
+        {
+            var member = (JsonNewMember)ElementType.JSON_NEW_MEMBER.Create();
+            member.AddChild(JsonNewTokenNodeTypes.DOUBLE_QUOTED_STRING.CreateLeafElement($"\"{key}\""));
+            member.AddChild(JsonNewTokenNodeTypes.COLON.CreateLeafElement());
+            member.AddChild(value);
+            return member;
+        }
+    }
+}