• Unity uses special .meta files for all assets when it used with source control.
• MonoBehaviours and other script types in Unity require the file name to match the class name.
• ReSharper is helpful: 'Refactor-Rename class' has option to rename files

Not so helpful: It doesn't know about .meta files. So when a file is renamed outside of the Unity Editor it will detect the change as a delete/add and not a rename/move. (I'm guessing this is more of a Unity Tools for VS/VS issue rather than a ReSharper issue.)

A partial fix for this, which I think will be good enough is to make sure to also rename the .meta files as otherwise Unity will generate a new meta file for the "new" script file (with a new GUID).

When that happens all script references to the renamed script file in scenes and on prefabs will become invalid because they still reference the old meta file (GUID) but no script file exists for it anymore...

P.S:
A "total" fix might be possible because Unity exposes an API for interacting with source control but it is probably too much of a hassle to get it to work correctly, maintain it and for it to still be user friendly. Because it would require the plugin to call into the Unity process and wait on a async task to finish which may or may not complete successfully depending on connectivity to source control or the source control state of the file ("added but not pushed", "not checked out" etc.) i.e. a can of worms...

To skip "field is newer assigned" warning with private fields with SerializeField (assigned via inspector) I had to flood my code with "#pragma warning disable 649" and "#pragma warning restore 649". Will be good to skip this warning somehow if possible

The extension sets ReSharper's C# language level to C# 5, as existing versions of Unity don't support C# 6. Unity 5.5 will target .net 4.6 and use the C# 6 compiler, so we shouldn't change language level in this case.

• How do we decide this? Based on version of unity assemblies?
• The article describes changing the target to .net 4.6 - is there a flag in the project file for this?
• Should we still set it for older Unity versions?

It seems whatever compiler Unity uses is not capable of inferring types in generics when passing in method groups.

For example:

    public class Foo
    {
        private Dictionary<Type, Func<string, object>> funcs = new Dictionary<Type, Func<string, object>>();

        public void AddFunc<T>(Func<string, T> func)
        {
            funcs.Add(typeof(T), (name) => func(name));
        }

        public Foo()
        {
            AddFunc(PlayerPrefs.GetString);
        }
    }

This is valid code, but does not compile in Unity because it seems incapable of deciding between the overloads of PlayerPrefs.GetString(string key) and PlayerPrefs.GetString(string key, string defaultValue)... probably a low priority bug in their mono compiler that's never been addressed.

Specifying the <string> directly gets it to compile eg: AddFunc<string>(PlayerPrefs.GetString), but then R# flags this argument specification as redundant.

Hello,

Can you please update the plugin so it can be installed with resharper 2016.2

Thank you,

Supress "field is never assigned" for public (and marked as [SerializeField]) fields in classed derived from MonoBehaviour

Sometimes it can be handy to use Start() callback as a Coroutine, see:
http://answers.unity3d.com/questions/754968/can-monobehaviorstart-return-an-ienumerator-hint-y.html
Resharper-unity supports void Start(), but not IEnumerator Start() for now. There are some other default Monobehavior callbacks with same feature, but docs a lack of info.

Hey,
sadly it does not show up the extension manager.
I am using the newest version of Resharper 9.2 and the bundeled vs Studio version 2015 community.
I would like to try out the extension. Sounds very helpful.
Greetings

Would it be possible to get a similar feature for Unity color types ?

Here is how the original feature works in Resharper:

https://www.jetbrains.com/help/resharper/2016.1/Coding_Assistance__Color_Assistance.html

Thank you 👍

In Unity its a common case to use private instance field (field type dosen matter) with SerializeFieldAttribute.
This makes that field value be available for editing from Unity inspector and assigned value will be provided with Unity serializtion system.
But resharper tends to threat private fields with SerializeFieldAttribute as never assigned.
Even more, if such fields have a default initializer, resharper tends to make them const or readonly, which prevents them from being edited in Unity inspector.

Unity docs:
http://docs.unity3d.com/ScriptReference/SerializeField.html

So the suggestion is:
If a field have SerializeFieldAttribute never mark it as "never assigned" and never propose a "readonly" or "const" keywords into it.

Resharper wants to both modify namespaces to include the top level Assets folder as well as add Assets to the namespace of generated classes. I don't think most people want this.

Update plugin for comparability with ReSharper 2016.2

Right now in order to share an ExternalAnnotation.xml file across my team we have to add the Library/UnityAssemblies/UnityEngine.ExternalAnnotations.xml file to version control. Is there any way we can add an external annotation file to this without having to add my Library folder to the repo?

Hello!

As Unity explains:

When you do this in Unity:
if (myGameObject == null) {}

It behaves inconsistently with the ?? operator, which also does a null check, but that one does a pure c# null check, and cannot be bypassed to call our custom null check.

Source: http://blogs.unity3d.com/2014/05/16/custom-operator-should-we-keep-it

This suggestion might mislead the programmer while comparing UnityEngine.Objects.
Would it be possible to supress it?

Thanks in advance!

PS. Huge thanks for this amazing utility 😄 !

Unity is compiled with mono, which doesn't support C#6, so ReSharper shouldn't use or suggest C#6 features, when running mono projects in VS2015.

The plugin should detect when a mono solution has been opened, and automatically set language level to C#5 for all projects.

Currently I get an "Unassigned field" warning on fields that are private but with a [SerializeField] attribute. These fields are set by Unity serialization. Marking them with [UsedImplicitly] fixes this and seems like the correct thing to do, but could perhaps also live in this plugin since it does a similar thing for e.g. Awake and Update on MonoBehaviour.

This is maybe more complex than it seems though since it would have to work not just MonoBehaviour and ScriptableObject fields, but on any fields in classes serialized by them. Just fields directly on those classes would be a good start though!

These classes are used by the Unity Editor to create custom inspector editors and are actually detected by the presence of this attribute.

Any AssetProcessor.OnGeneratedCSProjFiles is called after Unity generates files. But it's not documented, and our list of known Unity messages comes from the documentation. This should get included in the list so that we don't mark OnGeneratedCSProjFiles as unused.

https://gist.github.com/prime31/35a83fb8ad4eb385ab22

Hint that Exp, Sin, Cos, Tan, Sqrt, Pow and even / and % are expensive, especially when inside of the Update method of a MonoBehaviour.

When you have things like events tied to button clicks, they are embedded in the .unity (scene) file as strings. (see m_MethodName: in a text (not binary) scene file).

When Resharper suggests changing the method name in the .cs file, it should take into account any matches in scene files. If the method name is changed, R# should also change it in the scene file to keep them linked.

The plugin sets the default C# level to 5 rather than "default" (so VS2015 doesn't suggest C# 6 features), but Unity only supports C# 4. Unless the .csproj's <LangVersion> element says differently, override the current language version to 4.

It's probably a project specific issue so if it's hard to implement or you don't feel it should be part of the plugin just close it :)

Right now plugin disables Assets/Scripts from "namespace providers", but for example my project due to historic reasons (hello port from Java/Intellij Idea) has such code structure:
Aseets/Code/Module 1/src/"namespace included folders"
Aseets/Code/Module 2/src/"namespace included folders"
...

So if I could add some other folders to "disabled namespace providers list" either in some options or in some xml/ini file it would be awesome.

Better syntax highlighting and and code completion for Unity3D shaders. Extra points for adding in a way to view the results of said shader in a preview window.

Make it more obvious when a method is a Unity message by showing a gutter icon for the method.

Renaming serialized fields in Unity can result in loss of data/serialized references if they are not marked with a FormerlySerializedAs attribute to denote their previous names.

Ideally ReSharper should add it when doing a rename refactor, such that renaming both fields below...

... would result in something like this:

See https://docs.unity3d.com/ScriptReference/SerializeField.html for a list types that are serializable, though it is missing some info: Classes marked with the System.Serializable attribute can also be serialized (provided they contain serializable types)

If renaming a field that already has a FormerlySerializedAs attribute it should append add a new attribute
FormerlySerializedAs attribute (that is, is should not overwrite the existing one).

Like this we would not have to search for the correct parameters for OnCollisionTrigger2D anymore for example. :)
So if its not too hard to do it would be cool to have.

I have Unity Support extension 1.3.0 installed. The extensions seem to work when editing the the main unity project within the solution. I also have a project for a managed dll which sits along side the unity project. The project for the managed dll references the unity engine dlls but doesn't appear to be using the Unity Support extension. eg when viewing the code for my MonoBehaviour in the extension dll project I still get unused method warnings.

Add inspections to ensure callback methods marked with the DrawGizmo attribute are defined with the correct parameters, e.g.

[DrawGizmo (GizmoType.Selected | GizmoType.Active)]
static void DrawGizmoForMyScript (MyScript scr, GizmoType gizmoType)

This must have two parameters, one object that is the target, and the second is GizmoType. The inspection should verify the type of the target object. (What is this type? MonoBehaviour? Component?)

In Unity, OnGUI is a function that is called by the editor to render a user interface, either in game or (more importantly) when writing editor extensions.

Resharper marks this method has having inconsistent naming as the suggested name is OnGui, obviously this would break the functionality of the method. Resharper should recognize it as a built in Unity function and ignore the naming inconsistencies.

Resharper also marks this method as unused when leaving out the [UsedImplicitly] attribute, even though it is being called by the engine.

Thank you for your continued support on this extension, it has helped me tremendously!

When [SerializeField] is used ReSharper still says that field is never assigned. Thanks.

I'm on the bleeding edge of ReSharper and currently testing out ReSharper 10.1 EAP, but unfortunately, Unity for ReSharper exist in ReSharper Extensions screen and the previously installed Unity for ReSharper plugin doesn't get loaded.

Steps to Reproduce:

1. Install ReSharper 10.1 EAP 6 into Visual Studio
2. Open Unity project in Visual Studio
3. Notice Unity for ReSharper isn't working
4. Look for Unity for ReSharper in ReSharper Extension Manager

Results:
Unity for ReSharper isn't found.

Expected Results:
Unity for ReSharper is available to install.

When using Refactor-Encapsulate with the private field option on public serialized fields in Unity data loss can occur because private fields must be marked for serialization explicitly. Ideally an encapsulation-refactor in resharper-unity should turn this:

Into something like this:

(Depending on what was selected in the refactor dialog window of course, in this case the field was set to private as well.)

Do note that since the name chosen for the property was the same as the field already had, ReSharper has also renamed the backing field to avoid a name collision, in those instances it should also mark the field with a FormerlySerializedAs attribute with the old field-name as an argument, so you would end up with is something like this:

For Example:

using UnityEngine;

public class Example : MonoBehaviour
{
    private void Start()
    {
        Invoke("SomeMethod", 0f);
    }

    void SomeMethod() // <- Marked as never used
    {
        Debug.Log("Hello World");
    }
}

Resharper suggested null propagation for an if statement, however this language construct is not supported by Unity.

Would like an option to right-click a field on a ScriptableObject field and make migrations such as field rename, type migrations (perhaps via a user custom static method to make conversion of individual objects).

Hello,

After upgrading to ReSharper 2016.1 , the Unity extension was removed and is no longer available in the Extension Manager.

Cheers,

It doesn't appear in my Extension Manager :-(

http://imgur.com/cjnimga

http://imgur.com/aEwEMAj

http://docs.unity3d.com/ScriptReference/MenuItem.html

Thanks!

While the exclusion of "Assets\Scripts" from the namespace providers was a great addition, it would be nice if this was configurable. For example, in my case, my scripts are stored in "Assets\Scripts". It's common for folks who provide third party Unity packages to layout their project in this manner. I don't want Resharper to include "<CompanyName<ProductName>\Scripts" in my namespace. Making namespace providers configurable would solve my issue.

Use ReSharper's Extension Manager (ReSharper → Extension Manager), search for "Unity" and install. Restart, and it'll just start working.

I don't see this option. I see an Add that takes the name and URL. Thoughts?

I've got solution-wide analysis turned on in addition to colour-identifiers. These methods are shaded slightly to indicate they're not used by anything, but solution-wide analysis does not have an issue with them.

I think they should not be shaded; they're definitely used by Unity.

Hello,
I just installed the new Unity Plugin version 1.2.0 and noticed that after I opened my unity project, if I try to invoke the Resharper Options menu , the background turns pitch dark which makes it impossible to read the text and make changes. It is important to mention that this behavior does not happen if I open a different c#/.NET or c++ prjects. It seems like it only happens when I open a MonoBehavior project (a.k.a Unity).

How to reproduce:

1. Install Reharper Ultimate version 10.0.2.
2. Install Unity Support extension version 1.2.0
3. Open a new MonoBehavior project , either via Unity Editor or straight from Visual Studio.
4. Click on Resharper -> Options and then choose Intellisense -> autopopup for instance.

EDIT:
I forgot to mention that I am running on Windows 10.

here is a screenshot:

This feature is present in the MonoDevelop as separated plugin and in the VS by default.

Scripts linking drops from prefabs after moving files inside rider.

issue moved from https://github.com/JetBrains/Unity3dRider/issues/17

Would be nice to add support for methods marked with callback attributes like [DidReloadScripts]:
http://docs.unity3d.com/ScriptReference/Callbacks.DidReloadScripts.html

and any other attributes from the UnityEditor.Callbacks namespace

E.g. Given something like

using UnityEngine;
using UnityEditor;

public class MyObject : ScriptableObject 
{
  public int myInt = 42;
}

public class SerializedProperty : MonoBehaviour 
{
  void Start () 
  {
    MyObject obj = ScriptableObject.CreateInstance<MyObject>();
    SerializedObject serializedObject = new SerializedObject(obj);

    SerializedProperty serializedPropertyMyInt = serializedObject.FindProperty("myInt");

    Debug.Log("myInt " + serializedPropertyMyInt.intValue); 
  }
}

• Create a reference provider for the "myInt" string literal to reference the MyObject.myInt field, providing find usages + rename support
• The reference provider would provide a candidate list of available public fields to power code completion in the string literal
• Flow type information from the property name to the usage of the property, so that the correct accessor is used - if myInt is actually a string, then serializedPropertyMyInt.intValue will fail. It should suggest serialisedPropertyMyInt.stringValue

This is difficult, and would require control flow analysis. The FindProperty call would need to know the type of the object passed to new SerializedObject(obj). And the returned SerializedProperty would need some "type" information attached.

The extension does not work when using visual studio "15" preview 4 with visual studio vnext tools package :(

Hey, would be nice to add EditorWindow messages to make Resharper ignore such methods as OnEnable and do not mark them as not used, just like you did for the usual MonoBehaviour.

if Foo does not exist (or cant be found and used) offer to create a new class that derives from MonoBehaviour and has a start and update method defined, much like when creating a script inside of the Unity3D editor.

In addition to [MenuItem] mentioned in #19, Unity classes with [InitializeOnLoad] should also be marked as [UsedImplicitly] automatically.

http://docs.unity3d.com/ScriptReference/InitializeOnLoadAttribute.html

If I am inside of a Unity project I would like to limit the code suggestions to the versions of .net that are supported by Unity3D.