12

Consider the following source:

static void Main(string[] args)
{
    bool test;

    Action lambda = () => { test = true; };
    lambda();

    if (test)
        Console.WriteLine("Ok.");
}

It should compile, right? Well, it doesn't. My question is: according to C# standard, should this code compile or is this a compiler bug?

The error message:

Use of unassigned local variable 'test'

Note: I know, how to fix the error and i partially know, why does it happen. However, the local variable is assigned unconditionally and I guess, that compiler should notice that, but it does not. I wonder, why.

Comment for answers: C# allows declaring unassigned variables and that's actually quite useful, ie.

bool cond1, cond2;
if (someConditions)
{
    cond1 = someOtherConditions1;
    cond2 = someOtherConditions2;
}
else
{
    cond1 = someOtherConditions3;
    cond2 = someOtherConditions4;
}

Compiler compiles this code properly and I think, that leaving variables unassigned actually makes the code a little bit better, because:

  • It tells the reader, that values are assigned later (mostly probably in the following conditional statement)
  • Forces the programmer to assign the variables in all branches of internal conditions (if it was the purpose of this code from the beginning), because compiler will refuse to compile the code if one of the branches does not assign one of them.

On the margin: That's even more interesting. Consider the same example in C++:

int main(int argc, char * argv[])
{
    bool test;

    /* Comment or un-comment this block
    auto lambda = [&]() { test = true; };
    lambda();
    */

    if (test)
        printf("Ok.");

    return 0;
}

If you comment the block out, compilation ends with warning:

main.cpp(12): warning C4700: uninitialized local variable 'test' used

However, if you remove the comment, compiler emits no warnings whatsoever. It seems to me, that it is able to determine, if the variable is set after all.

Improve this question
9
  • 3
    The compiler will not assume the line that assigns test has been reached. I don't know if that is because of basic code flow analysis that doesn't follow method calls, or if it is due to the way closed over locals are turned into code-genned class members, or perhaps both or neither. But either way, initialize the variable to false upon declaration. Commented Jan 8, 2013 at 21:21
  • I know that. My question is: why compiler won't assume, that test assignment is reached, when there are no conditional expressions on the way? Commented Jan 8, 2013 at 21:23
  • 9
    -1 for not even including the error message. Commented Jan 8, 2013 at 21:23
  • 2
    @Spook First off, no, it doesn't need to be a lambda, it needs to be a closure, which could also be an anonymous delegate (delegate { test = true; };). Second, knowing that the local variable is assigned within the delegate is not hard. In fact, to maintain closure semantics is must already know that the local is accessed in the closure and hoist it. The difficult question is determining whether or not that delegate is executed at some point and marking the variable as having a defined value at that point. It's a non-trivial problem in the general case. Commented Jan 8, 2013 at 21:40
  • 2
    This case is covered (almost exactly this) at 12.3.3.27 of the C# spec. Commented Jan 8, 2013 at 21:51

4 Answers 4

Reset to default
17

My question is: according to C# standard, should this code compile or is this a compiler bug?

This is not a bug.

Section 5.3.3.29 of the C# Language Specification (4.0) outlines the definite assignment rules regarding anonymous functions, including lambda expressions. I will post it here.

5.3.3.29 Anonymous functions

For a lambda-expression or anonymous-method-expression expr with a body (either block or expression) body:

  • The definite assignment state of an outer variable v before body is the same as the state of v before expr. That is, definite assignment state of outer variables is inherited from the context of the anonymous function.

  • The definite assignment state of an outer variable v after expr is the same as the state of v before expr.

The example

delegate bool Filter(int i);

void F() {
    int max;

    // Error, max is not definitely assigned    
    Filter f = (int n) => n < max;

    max = 5;    
    DoWork(f); 
}

generates a compile-time error since max is not definitely assigned where the anonymous function is declared. The example

delegate void D();

void F() {    
    int n;    
    D d = () => { n = 1; };

    d();

    // Error, n is not definitely assigned
    Console.WriteLine(n); 
}

also generates a compile-time error since the assignment to n in the anonymous function has no affect on the definite assignment state of n outside the anonymous function.

You can see how this applies to your specific example. The variable test is not specifically assigned prior to the declaration of the lambda expression. It is not specifically assigned prior to the execution of the lambda expression. And it is not specifically assigned after the completion of the lambda expression execution. By rule, the compiler does not consider the variable to be definitely assigned at the point of it being read in the if statement.

As for why, I can only repeat what I have read on the matter, and only what I can remember as I cannot produce a link, but C# does not attempt to do this because, although this is a trivial case that the eye can see, it is far more often the case that this type of analysis would be non-trivial and indeed could amount to solving the halting problem. C# therefore "keeps it simple" and requires you to play by much more readily applicable and solvable rules.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

And that's precisely what I was asking for. Thanks! (curious, that in C++ these rules seems to be a little different, though)
@Spook: In C++ it is not a compile-time error to use an uninitialized variable, though at run-time you will get undefined behavior. The warning you're getting is just the compiler being nice; it certainly won't try to figure it out in every case.
Ok, but when I remove comment from the lambda block of code, compiler stops to inform about the variable not being assigned - in other words, conditions to mark variable as used-when-not-assigned are no longer met. At least this is how it looks like.
4

You are using unassigned variable. Even though the variable is actually assigned, compiler has no way of inferring that from the code you've posted.

All local variables should be initialized when declared anyway, so this is interesting, but still erroneous.

Improve this answer

4 Comments

My actual question is not: why the code doesn't compile, but: why compiler has no way of telling, that variable is assigned, despite there are no conditional statements?
-1: The local variable is assigned before it is used, the compiler is just too dense to figure that out.
@ChrisDodd: While the answer is wrong in saying it has "no way of inferring it", you're just as wrong saying it's "too dense", trivializing the problem. This is a solvable problem but it's not trivial in general.
@GManNickG: A better way to characterize the situation is: (1) the general problem of determining definite assignment is unsolvable because it is equivalent to the Halting Problem, (2) because of that, the C# specification strictly defines "definite assignment" in a manner that sometimes reports "not definitely assigned" when the variable is in fact definitely assigned, and (3) in this specific case, an interprocedural flow tracking algorithm could work, but would not be consistent with the specified behaviour.
2

When the compiler is performing control flow analysis of methods to determine whether or not a variable is definitely assigned it will only look within the scope of the current method. Eric Lippert discusses this in this blog post. It's theoretically possible for the compiler to analyze methods called from within the "current method" to reason about when a variable is definitely assigned.

As I mentioned before, we could do interprocedural analysis, but in practice that gets real messy real fast. Imagine a hundred mutually recursive methods that all go into an infinite loop, throw, or call another method in the group. Designing a compiler that can logically deduce reachability from a complex topology of calls is doable, but potentially a lot of work. Also, interprocedural analysis only works if you have the source code for the procedures; what if one of these methods is in an assembly, and all we have to work with is the metadata?

Keep in mind that your code example is not truely a single method. The anonymous method will be refactored into another class, an instance of it will be created, and it will be calling a method that resembles your definition. Additionally the compiler would need to analyze the definition of the delegate class as well as the definition of Action to reason that the method you provided was actually executed.

So while it's within the bounds of theoretical possibility for the compiler to know that the variable is reachable in that context, the compiler writers deliberately choose not to both due to the complexity of writing the compiler for it, and also the (potentially significant) increase in time it would take to compile programs.

Improve this answer

Comments

0

A snippet from the ECMA Standard section 8.3 Variables and Parameters:

A variable shall be assigned before its value can be obtained. The example

class Test
{
    static void Main() {
    int a;
    int b = 1;
    int c = a + b; // error, a not yet assigned

    }
}

results in a compile-time error because it attempts to use the variable a before it is assigned a value. The rules governing definite assignment are defined in §12.3.

Therefore it states that the variable must be assigned before it is used otherwise it results in a compiler error. Because you are creating a delegate and invoking it, the method that is contained within the delegate invocation is technically not known. Therefore the compiler would not be to figure it out. Remember it is the Delegate's Invoke method that is being called not the actual method.

ECMA Standard for C#

Improve this answer

4 Comments

For this to be a decent answer you'll need to do more than say "the spec says it's not definitely assigned" with a link to the specs...What makes this case even worth talking about is that the variable is definitely assigned, the compiler just can't tell due to the complexity of the example.
So, first off, everything before the last paragraph and the link is useless, and should just be removed. Clearly that's nothing new to the OP. Next, while you're starting to discuss the issue, it's not really an answer, it's just begging the question, "why can't the compiler know that invoking the delegate, which id definitely done, and definitely assigns the local, result in the local being definitely assigned. It's really not much of an answer.
This case is covered (almost exactly this) at 12.3.3.27 of the C# spec.
@AustinSalonen Yes, did not see that when I was lookign at the spec. Thanks for pointing it out.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.