Как я могу надежно определить тип переменной, объявленной с помощью var во время разработки?

Я работаю над завершением (intellisense) объекта для C# в emacs.

идея заключается в том, что если пользователь вводит фрагмент, а затем запрашивает завершение с помощью определенной комбинации клавиш, средство завершения будет использовать отражение .NET для определения возможных завершений.

для этого требуется, чтобы тип завершаемой вещи был известен. Если это строка, существует известный набор возможных методов и свойств; если это Int32, он имеет отдельный набор, и так далее.

используя semantic, пакет code lexer/parser, доступный в emacs, я могу найти объявления переменных и их типы. Учитывая это, легко использовать отражение для получения методов и свойств типа, а затем представить список параметров пользователю. (Хорошо, не совсем простой сделать внутри Emacs, но с помощью возможность запуска процесса powershell внутри emacs, оно становится гораздо проще. Я пишу пользовательскую сборку .NET для отражения, загружаю ее в powershell, а затем elisp, работающий в emacs, может отправлять команды в powershell и читать ответы через comint. В результате emacs может быстро получить результаты отражения.)

проблема возникает, когда код использует var в объявлении вещи завершается. Это означает, что тип явно не указан, и завершение не будет работать.

как я могу достоверно определить фактический тип используется, когда переменная объявляется с помощью var ключевое слово? Просто чтобы быть ясным, мне не нужно определять его во время выполнения. Я хочу определить его в "время разработки".

пока у меня такие идеи:

1. компиляция и вызов:
   • извлеките оператор объявления, например 'var foo = "строковое значение";'
   • объединить заявление ' foo.GetType ();'
   • динамически скомпилировать полученный фрагмент C# в новый сборка
   • загрузите сборку в новый домен приложения, запустите framgment и получите тип возврата.
   • выгрузить и выбросить сборки

   Я знаю, как все это делать. Но это звучит ужасно тяжеловесно, для каждого запроса на завершение в Редакторе.

   Я полагаю, что мне не нужен свежий новый домен приложений каждый раз. Я мог бы повторно использовать один домен приложения для нескольких временных сборок и амортизировать стоимость его установки и рвет его вниз, через несколько запросов на завершение. Это больше настройка основной идеи.

2. компиляция и проверка IL

   просто скомпилируйте объявление в модуль, а затем проверьте IL, чтобы определить фактический тип, который был выведен компилятором. Как это возможно? Что бы я использовал для изучения IL?

есть идеи получше? Комментарии? предложения?

EDIT - думая об этом дальше, compile-and-invoke неприемлемо, потому что вызов может иметь побочные эффекты. Поэтому первый вариант должен быть исключен.

кроме того, я думаю, что я не могу предположить наличие .NET 4.0.

обновление - правильный ответ, не упомянутый выше, но мягко отмеченный Эриком Липпертом, заключается в реализации полной системы вывода типа точности. Это единственный способ надежно определить тип переменной во время разработки. Но, это также не так просто сделать. Поскольку у меня нет иллюзий, что я хочу попытаться построить такую вещь, я взял ярлык варианта 2 - извлечь соответствующий код декларации и скомпилировать его, а затем проверить полученный IL.

это действительно работает, для справедливого подмножества сценариев завершения.

например, предположим, что в следующих фрагментах кода, то ? это позиция, в которой пользователь запрашивает завершение. Это работает:

var x = "hello there"; 
x.?

в завершение понимает, что x является строкой, и предоставляет соответствующие параметры. Он делает это путем создания и последующей компиляции следующего исходного кода:

namespace N1 {
  static class dmriiann5he { // randomly-generated class name
    static void M1 () {
       var x = "hello there"; 
    }
  }
}

...а затем осматривает ил с простым отражением.

это также работает:

var x = new XmlDocument();
x.? 

двигатель добавляет соответствующие предложения using к сгенерированному исходному коду, так что он компилируется должным образом, а затем проверка IL такая же.

это работает, тоже:

var x = "hello"; 
var y = x.ToCharArray();    
var z = y.?

это просто означает, что проверка IL должна найти тип третьей локальной переменной, а не первой.

и так:

var foo = "Tra la la";
var fred = new System.Collections.Generic.List<String>
    {
        foo,
        foo.Length.ToString()
    };
var z = fred.Count;
var x = z.?

...это всего лишь на один уровень глубже, чем предыдущий пример.

но, что не работа завершается с любой локальной переменной, инициализация которой зависит в любой момент от члена экземпляра или аргумента локального метода. Например:

var foo = this.InstanceMethod();
foo.?

ни LINQ синтаксис.

мне придется подумать о том, насколько ценны эти вещи, прежде чем я подумаю о том, чтобы обратиться к ним через то, что определенно является "ограниченным дизайном" (вежливое слово для взлома) для завершения.

подход к решению проблемы с зависимостями от аргументов метода или методов экземпляра будет заключаться в замене во фрагменте кода, который генерируется, компилируется и затем анализируется IL, ссылки на эти вещи с "синтетическими" локальными vars того же типа.

Еще Одно Обновление - завершение на vars, которые зависят от членов экземпляра, теперь работает.

то, что я сделал, это опрос типа (через семантику), а затем создать синтетические резервные члены для всех существующих членов. Для буфера C#, как это:

public class CsharpCompletion
{
    private static int PrivateStaticField1 = 17;

    string InstanceMethod1(int index)
    {
        ...lots of code here...
        return result;
    }

    public void Run(int count)
    {
        var foo = "this is a string";
        var fred = new System.Collections.Generic.List<String>
        {
            foo,
            foo.Length.ToString()
        };
        var z = fred.Count;
        var mmm = count + z + CsharpCompletion.PrivateStaticField1;
        var nnn = this.InstanceMethod1(mmm);
        var fff = nnn.?

        ...more code here...

...сгенерированный код, который компилируется, так что я могу узнать из выходных данных IL тип локального var nnn, выглядит так:

namespace Nsbwhi0rdami {
  class CsharpCompletion {
    private static int PrivateStaticField1 = default(int);
    string InstanceMethod1(int index) { return default(string); }

    void M0zpstti30f4 (int count) {
       var foo = "this is a string";
       var fred = new System.Collections.Generic.List<String> { foo, foo.Length.ToString() };
       var z = fred.Count;
       var mmm = count + z + CsharpCompletion.PrivateStaticField1;
       var nnn = this.InstanceMethod1(mmm);
      }
  }
}

все члены экземпляра и статического типа доступны в скелетном коде. Он успешно компилируется. В этот момент определение типа локального var является простым с помощью отражения.

что делает это возможным-это:

• возможность запуска powershell в emacs
• компилятор C# очень быстро. На моей машине для компиляции сборки в памяти требуется около 0,5 С. Недостаточно быстро для анализа между нажатиями клавиш, но достаточно быстро, чтобы поддержка формирования списков завершения по требованию.

Я еще не заглядывал в LINQ.
Это будет гораздо большая проблема, потому что семантический лексер/парсер emacs имеет для C#, не "делает" LINQ.