C#에서 사용자 정의 예약어가 가능할까요?

마침, 최근 C# 개발자들 사이에서 이런 토론이 있었습니다.

Subject: User defined keywords.
Date: Tue, 15 Apr 2014 23:27:20 -0400
  I see that now with Roslyn people are having lots of ideas. But I actually don't plan to release my own compiler based on Roslyn, I would really like to improve C# and .NET in general.

  A thing that I really miss in C# (and in all languages that I use) is the possibility for the users to create their own "keywords"/control flow structures.

  I will try to explain with an example. Imagine this code:
  abortsafeusing(var someResource = new ResourceThatShouldNotBeAborted())
  {
    someResource.DoSomething();
  }

  It could be translated into this:
  {
    ResourceThatShouldNotBeAborted someResource = null;
    try
    {
      try
      {
      }
      finally
      {
        // code inside a finally will never be aborted.
        someResource = new ResourceThatShouldNotBeAborted();
      }

      // an abort while executing DoSomething is not the problem.
      // the resource acquisition and the dispose must be guaranteed.
      someResource.DoSomething();
    }
    finally
    {
      if (someResource != null)
        someResource.Dispose();
    }
  }

What I am saying here is not that I want the C# team to add the abortsafeusing. I know that abort is bad and this is not the point. The point is: What if the language allowed me to create such "keyword"? Or, of course, any other I see fit?

Note that using delegates doesn't give the same effect. A delegate can't do an yield return for the main body of a method, while a code inside a using body can (and, if these user keywords were supported, it will be possible too).

How could this be done?
By methods decorated with some specific attribute.
By classes/structs that implement a specific interface.

Imagine that the abortsafeusing was implemented by a class like this:
[UserKeyword(name="abortsafeusing")]
public sealed class AbortSafeUsing<T>:
  UserBlockKeywordThatDeclaresAVariable<T>
where
  T: IDisposable
{
  private T _objectToDispose;
  protected override void BlockEnter(Func<T> value)
  {
    try
    {
    }
    finally
    {
      _objectToDispose = value();
    }
  }

  // The exception is null when the block ends normally, but contains
  // the exception if it ends forcibly.
  protected override void BlockExit(Exception exception)
  {
    if (_objectToDispose != null)
      _objectToDispose.Dispose();
  }
}

I understand that without analyzing the IL the final code will actually include a creation of an instance of the AbortSafeUsing class. Yet, as a user, I will be able to add a new "keyword" to the language. By allowing the "user keywords" to be combined we could simulate user made ifs, elses, switches and others. This could actually simplify a lot of places that are using delegates today, will behave more normally (as a return inside one of those user made blocks will return the actual method, not the delegate method) and will not be limited to a single action.

We can say that if we had that support from the start that the using, the foreach and the lock keywords could be "user made" keywords. And, of course, if the .NET itself could "inline" the code inside the BlockEnter/BlockExit calls and avoid the construction of the class it would be even better.

My idea is that such keywords need to be imported, maybe the same way we do with the using to import namespaces (and that's now expanded to support classes).

So, what do you think?
I personally see a lot of potential to create "declarative like" APIs that are actually built in real C# code.