Add more information when displaying a "read-only variable is not assignable" error

[rtrieu]

Summary

http://llvm.org/bugs/show_bug.cgi?id=19139

When a "read-only variable is not assignable" is emitted, give additional notes to show where the const is location.

$ cat test.cc
const int k = 1;
void f() { k = 0; }
class X {
  int i;
  const int j = 1;
  void f() const { i = 0; }
  void g() { j = 0; }
};
$ old_clang test.cc -std=c++11
test.cc:2:14: error: read-only variable is not assignable
void f() { k = 0; }
           ~ ^
test.cc:6:22: error: read-only variable is not assignable
  void f() const { i = 0; }
                   ~ ^
test.cc:7:16: error: read-only variable is not assignable
  void g() { j = 0; }
             ~ ^
3 errors generated.
$ new_clang test.cc -std=c++11
test.cc:2:14: error: read-only variable is not assignable
void f() { k = 0; }
           ~ ^
test.cc:1:11: note: variable 'k' is declared here with type 'const int' which is const
const int k = 1;
~~~~~~~~~~^~~~~
test.cc:6:22: error: read-only variable is not assignable
  void f() const { i = 0; }
                   ~ ^
test.cc:6:8: note: method 'f' is declared const here
  void f() const { i = 0; }
  ~~~~~^~~~~~~~~
test.cc:7:16: error: read-only variable is not assignable
  void g() { j = 0; }
             ~ ^
test.cc:5:13: note: field 'j' is declared here with type 'const int' which is const
  const int j = 1;
  ~~~~~~~~~~^~~~~
3 errors generated.

[dblaikie]

An out-of-line definition might be interesting:

struct foo {
  int i;
  void f() const;
};
void foo::f() cont {
  i = 3;
}

does the diagnostic point to the definition of 'f' or the declaration?

Also, would it be better for the diagnostic to point to the "const" in the function rather than the "f"?

"of type 'const T' which is const" sounds a bit strange - any better way we could phrase this? Could we leverage/improve type diffing to allow a silent (silent in the sense that the non-const type is not printed in the diagnostic) comparison to the non-const type? ("X is declared with type '<const> int' here"?) Not sure how it would/should look when typedefs are involved.

[rtrieu]

$ cat c.cc
struct foo {
  int i;
  void f() const;
};
void foo::f() cont {
  i = 3;
}
$ clang c.cc
c.cc:6:5: error: read-only variable is not assignable
  i = 3;
  ~ ^
c.cc:5:11: note: method 'f' is declared const here
void foo::f() const {
~~~~~~~~~~^~~~~~~~~
1 error generated.

Note will point to function definition.

$ cat d.cc
typedef const int X;
void test(X x) {
  x = 5;
}
$ clang d.cc
d.cc:3:5: error: read-only variable is not assignable
  x = 5;
  ~ ^
d.cc:2:13: note: variable 'x' is declared here with type 'X' (aka 'const int') which is const
void test(X x) {
          ~~^
1 error generated.

No problems with typedefs.

I think the note should explicitly point out the const qualifier, otherwise the user will see "note: variable 'x' has type 'y'" which isn't very helpful. Perhaps "note: variable "x" is declared here with type 'const int'; const qualifier prevents assignment" would be better?

[rtrieu]

Also, would it be better for the diagnostic to point to the "const" in the function rather than the "f"?

Probably, but the location of the const on a function does not appear to be available.

[dblaikie]

In D4479#7, @rtrieu wrote:

Also, would it be better for the diagnostic to point to the "const" in the function rather than the "f"?

Probably, but the location of the const on a function does not appear to be available.

Mr. Smith - any thoughts on whether this should be available? Or is it just not feasible due to AST size costs? In any case, if it's not available, that's OK for this commit & maybe leave a FIXME in the test and in the source suggesting that it could be improved if we get that source fidelity in the AST some day.

In D4479#6, @rtrieu wrote:

$ cat c.cc
struct foo {
  int i;
  void f() const;
};
void foo::f() cont {
  i = 3;
}
$ clang c.cc
c.cc:6:5: error: read-only variable is not assignable
  i = 3;
  ~ ^
c.cc:5:11: note: method 'f' is declared const here
void foo::f() const {
~~~~~~~~~~^~~~~~~~~
1 error generated.

Note will point to function definition.

Great (not sure about the "declared const here" phrasing, though - technically true (a definition is a declaration, though most people think of the first declaration as "the declaration") and I can't think of much better, though)

$ cat d.cc
typedef const int X;
void test(X x) {
  x = 5;
}
$ clang d.cc
d.cc:3:5: error: read-only variable is not assignable
  x = 5;
  ~ ^
d.cc:2:13: note: variable 'x' is declared here with type 'X' (aka 'const int') which is const
void test(X x) {
          ~~^
1 error generated.

No problems with typedefs.

I think the note should explicitly point out the const qualifier, otherwise the user will see "note: variable 'x' has type 'y'" which isn't very helpful.

Depends if the 'y' has the word 'const' in it, in which case it's fairly helpful. Though that's why I was suggesting possibly repurposing the type diffing code to highlight the "const"-ness.

Perhaps "note: variable "x" is declared here with type 'const int'; const qualifier prevents assignment" would be better?

That sounds pretty good to me. Would have to see it in a few more examples (like the const this pointer case, etc) to see how the phrasing generalizes.

Open to other people's ideas too, hopefully there's some other opinions - mine are by no means "golden".

[rtrieu]

Improve the wording of the error message. Make the error more informative by taking the information from the notes and moving it to the error message.

[rsmith]

+ "cannot assign to const data member %1 with const qualified type %2|"

Replace the "const data member" with "data member" here; we don't need to
point out the constness twice. (Likewise below)

+ "cannot assign to data member within const member function %1|"

"data member" is not the right term here. Use either "non-static data
member" or "field" (we tend to use the latter in diagnostics that might
appear in C, and the former in exclusively C++ diagnostics).

+ "cannot assign to const data member %1 with const qualified type %2 in a
"
+ "const member function %3}0">;

I don't think this last variant is useful: I think we should either point
out that the field's type is const, or that we're in a const member
function, not both. The way the diagnostic is phrased now might lead to
people thinking that removing *either* const would solve the problem.
Diagnosing the constness of the field seems better to me, since seems in
some sense more fundamental.

+def note_function_returns_const_ref : Note<
+ "function %0 which returns const qualified type %1 declared here">;
+def note_const_variable : Note<
+ "variable %0 declared const here">;
+def note_const_field : Note<
+ "field %0 declared const here">;
+def note_const_method : Note<
+ "member function %q0 is declared const here">;

Could you use a single diagnostic with a %select here?

+enum {
+ ConstUnknown,
+ ConstFunction,
+ ConstVariable,
+ ConstField,
+ ConstMethod,
+ ConstFieldAndMethod
+};

Move this inside the function.

+ PartialDiagnostic PD = S.PDiag(diag::err_typecheck_assign_const)
+ << E->getSourceRange();

Seems like weird indentation for the <<.

+ Handle class fields and methods.
+ if (const MemberExpr *Member = dyn_cast<MemberExpr>(E)) {
+ const Expr *Base = E;
+ while (Member) {
+ ValueDecl *VD = Member->getMemberDecl();
+ Class field is const.
+ if (VD->getType().isConstQualified()) {
+ ME = Member;
+ break;
+ }
+ Base = Member->getBase();
+ Member = dyn_cast<MemberExpr>(Base);
+ }

This loop should go before all the other checks, so that we can diagnose

const X x;
x.y.z = 3;

const X &f();
f().y.z = 3;

properly.

[rtrieu]

- + "cannot assign to const data member %1 with const qualified type %2|"
- 
- Replace the "const data member" with "data member" here; we don't need to
- point out the constness twice. (Likewise below)

Fixed

+ "cannot assign to data member within const member function %1|"

"data member" is not the right term here. Use either "non-static data
member" or "field" (we tend to use the latter in diagnostics that might
appear in C, and the former in exclusively C++ diagnostics).

removed const;

+ "cannot assign to const data member %1 with const qualified type %2 in a
"
+ "const member function %3}0">;

I don't think this last variant is useful: I think we should either point
out that the field's type is const, or that we're in a const member
function, not both. The way the diagnostic is phrased now might lead to
people thinking that removing *either* const would solve the problem.
Diagnosing the constness of the field seems better to me, since seems in
some sense more fundamental.

improved code

+def note_function_returns_const_ref : Note<
+ "function %0 which returns const qualified type %1 declared here">;
+def note_const_variable : Note<
+ "variable %0 declared const here">;
+def note_const_field : Note<
+ "field %0 declared const here">;
+def note_const_method : Note<
+ "member function %q0 is declared const here">;

Could you use a single diagnostic with a %select here?

Done

+enum {
+ ConstUnknown,
+ ConstFunction,
+ ConstVariable,
+ ConstField,
+ ConstMethod,
+ ConstFieldAndMethod
+};

Move this inside the function.

Done

+ PartialDiagnostic PD = S.PDiag(diag::err_typecheck_assign_const)
+ << E->getSourceRange();

Seems like weird indentation for the <<.

Added two more spances.

+ Handle class fields and methods.
+ if (const MemberExpr *Member = dyn_cast<MemberExpr>(E)) {
+ const Expr *Base = E;
+ while (Member) {
+ ValueDecl *VD = Member->getMemberDecl();
+ Class field is const.
+ if (VD->getType().isConstQualified()) {
+ ME = Member;
+ break;
+ }
+ Base = Member->getBase();
+ Member = dyn_cast<MemberExpr>(Base);
+ }

This loop should go before all the other checks, so that we can diagnose

const X x;
x.y.z = 3;

const X &f();
f().y.z = 3;
properly.

Added test cases and makes sure test runs proberl

[rsmith]

include/clang/Basic/DiagnosticSemaKinds.td

4817 ↗

(On Diff #12471)

Please use 'because' rather than 'since'.

4818–4819 ↗

(On Diff #12471)

There's a missing hyphen between "const" and "qualified" in both of these.

4819–4820 ↗

(On Diff #12471)

You have "data member" here but "field" below. This should be consistently "field" (or "non-static data member") in both places.

4823 ↗

(On Diff #12471)

Can you put something like ERROR in here so that we don't just get "note: " if this is somehow produced? (We do this in a few other diagnostics which have %select's with missing options.)

lib/Sema/SemaExpr.cpp

8485–8488 ↗

(On Diff #12471)

/// for this comment, please.

8526–8533 ↗

(On Diff #12471)

I don't think this does the right thing for a member reference within a lambda-expression (I think you'll pick up the wrong DC).

8543–8545 ↗

(On Diff #12471)

If we're in a lambda-expression and the variable got constified by lambda-capture, it'd be nice to point to the lambda and suggest that maybe it should be mutable. For simple cases, we seem to do that in CheckForModifiableLvalue, but not for member access cases. Maybe we should move more of the code from there into here?

8548–8553 ↗

(On Diff #12471)

I think ME should be first here (notionally, I think that the constness of the field is a more immediate problem than the fact that the function return type or the variable is declared const). This will also fix a bug in the current implementation with mutable members:

struct A { const int n; };
struct B { mutable A a; };
extern const B b;
void f() { b.a.n = 23; }

This should diagnose that A::n is const, but I think it'll incorrectly diagnose that b is const (which is irrelevant because B::a is mutable).

8562–8588 ↗

(On Diff #12471)

As noted above, these may be incorrect if we hit a mutable on the way.

[rtrieu]

Add additional test
Rewrite the loop to display notes and stop when no new notes are needed
Fix some wording with the diagnostic

[rtrieu]

include/clang/Basic/DiagnosticSemaKinds.td

4817 ↗

(On Diff #12471)

Done.

4819–4820 ↗

(On Diff #12471)

Went with "static data member" and "non-static data member".

4823 ↗

(On Diff #12471)

Switched the order of the enum so that ConstUnknown is last. The note has one less text in the select than the error, which will assert in the diagnostic printer if ConstUnknown is used as the note index.

lib/Sema/SemaExpr.cpp

8485–8488 ↗

(On Diff #12471)

Done.

8526–8533 ↗

(On Diff #12471)

Do you have an example of the lambda expressions you think this would not produce the correct diagnostic?

8548–8553 ↗

(On Diff #12471)

Notes are now produced in the order of AST node reached. Which means that:

get().x.y.z = 5;

will produce notes (if applicable) in order of z, y, x, then finally get().

For the mutable case, it should produce the correct diagnostic now, error on A::n and ignore the const b.

8562–8588 ↗

(On Diff #12471)

Done. No longer error on mutables.

[rtrieu]

"const qualified" -> "const-qualified"

[rsmith]

lib/Sema/SemaExpr.cpp

8488 ↗

(On Diff #12644)

Typo 'funciton'.

8508 ↗

(On Diff #12644)

Each iteration of this loop should IgnoreParenImpCasts or similar.

8514 ↗

(On Diff #12644)

Can you assert(DiagnosticEmitted) here?

8528 ↗

(On Diff #12644)

Do we need to track whether . or -> was used here? If we have:

struct A { const int n; };
extern A *p const;
p->n = 0;

... we shouldn't produce a note about p; its constness is not relevant. And conversely if we have:

struct B { int n; };
const B *q;
q->n = 0;

... then we should produce a note about q.

8549–8570 ↗

(On Diff #12644)

I'm not sure this special case makes sense as it stands. If I have:

struct A {};
struct B {
  const A f();
} const b;
void g() {
  b.f() = A();
}

... then it's not at all relevant that b is const, but I think I'll get a note telling me that it is. I think the appropriate check here is somewhat more sophisticated; if:

• we have a member call on a non-static member function, and
• that function is const, and
• there is a "similar" function with the same name that is not const, and
• the similar function has a non-const (or reference-to-non-const) return type

... then it matters that the object is const (and arguably we don't need to produce a note pointing at the member function).

This seems like a good enhancement to the basic mechanism here, but my preference would be to drop the member call part of this patch and add that enhancement as a separate patch.

8575 ↗

(On Diff #12644)

Use FD->getCallResultType().isConstQualified() here. (I don't think there are any functionality changes from that, but if there are, they would be bugfixes.)

8587 ↗

(On Diff #12644)

The constness of the callee doesn't seem relevant here; should probably just break at this point.

8594 ↗

(On Diff #12644)

It'd be nice to also handle reference-to-const here.

8611–8615 ↗

(On Diff #12644)

I worry that we'll diagnose "cannot assign to non-static data member within const member function" in response to:

struct X { void f() { this = new X; } };

As noted above, perhaps we should track whether we're assigning to the result of E or the result of dereferencing the result of E.

[rtrieu]

Extend the better error messages to more cases.
Centralize part of the const checking.
Update even more old test cases.

[rtrieu]

lib/Sema/SemaExpr.cpp

8488 ↗

(On Diff #12644)

Fixed.

8508 ↗

(On Diff #12644)

Call to IgnoreParenImpsCasts added.

8514 ↗

(On Diff #12644)

Oops, will get this on next patch.

8528 ↗

(On Diff #12644)

Dereference is now tracked by IsDereference and NextIsDereference. Those examples have been added to the tests.

8549–8570 ↗

(On Diff #12644)

Testing:

struct A {};
struct B {
  const A f() const;
} const b = {};
void g() {
  b.f() = A();
}

The error message is no viable overload since the implicit move and copy assignment operators for A are not marked const, which is a different code path.

Testing:

struct B {
    const int f() const;
} const b = {};
void g() {
    b.f() = 5;
}

Gives: expression is not assignable, also a different code path.

Testing:

struct B {
    const int& f() const;
} const b = {};
void g() {
    b.f() = 5;
}

Gives:

const.cc:65:11: error: cannot assign to return value because function 'f'
      returns a const value
    b.f() = 5;
    ~~~~~ ^
const.cc:62:11: note: function 'f' which returns const-qualified type
      'const int &' declared here
    const int& f() const;
          ^~~~
1 error generated.

Which does not show a message for b at all.

8575 ↗

(On Diff #12644)

Call to getNonReferenceType() is needed otherwise

const int& foo();
foo() = 5;

would fall through to the default error message below.

8587 ↗

(On Diff #12644)

break added.

8594 ↗

(On Diff #12644)

References are handled in IsTypeReadable

8611–8615 ↗

(On Diff #12644)

Dereferences are checked now. In this cases, assigning to this pointer causes a different error to be emitted:

const.cc:73:28: error: expression is not assignable
struct X { void f() { this = new X; } };
                      ~~~~ ^

[rsmith]

lib/Sema/SemaExpr.cpp

8780 ↗

(On Diff #20440)

Should this be called something more like isTypeModifiable?

8860–8882 ↗

(On Diff #20440)

Can you combine this with the general CallExpr check below? The only difference seems to be that you keep going after hitting a CXXMemberCallExpr, in case it's a MemberExpr with a const base object.

8877–8878 ↗

(On Diff #20440)

It'd be nice to condition this on the existence of another overload of the callee that is not const and has a non-const-qualified return type.

8887 ↗

(On Diff #20440)

Should you be using IsTypeReadable here?

test/Sema/assign.c

9 ↗

(On Diff #20440)

Please remove the path here :-)

[rtrieu]

lib/Sema/SemaExpr.cpp

8780 ↗

(On Diff #20440)

Done.

8860–8882 ↗

(On Diff #20440)

Removed handling for CXXMemberCallExpr. CallExpr below will handle the generic case. Will try to incorporate the overloaded member detection in a future change.

8887 ↗

(On Diff #20440)

Done.

test/Sema/assign.c

9 ↗

(On Diff #20440)

Path removed.

[rsmith]

LGTM, but I think the loop can be simplified slightly:

lib/Sema/SemaExpr.cpp

8859 ↗

(On Diff #23624)

Every code path below this point reaches a break; -- maybe end the loop here?

8874 ↗

(On Diff #23624)

The function will return anyway, because DiagnosticEmitted is now true. Remove this return for consistency with the other cases?

8876 ↗

(On Diff #23624)

This looks like a dead store. Remove?

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

def err_typecheck_comparison_of_distinct_pointers : Error<
   "comparison of distinct pointer types%diff{ ($ and $)|}0,1">;
 def ext_typecheck_comparison_of_distinct_pointers_nonstandard : ExtWarn<
   "comparison of distinct pointer types (%0 and %1) uses non-standard "
   "composite pointer type %2">, InGroup<CompareDistinctPointerType>;
 def err_typecheck_op_on_nonoverlapping_address_space_pointers : Error<
   "%select{comparison between %diff{ ($ and $)|}0,1"
   "|arithmetic operation with operands of type %diff{ ($ and $)|}0,1}2"
   " which are pointers to non-overlapping address spaces">;
-def err_typecheck_assign_const : Error<"read-only variable is not assignable">;
+
+def err_typecheck_assign_const : Error<
+  "%select{"
+  "cannot assign to return value because function %1 returns a const value|"
+  "cannot assign to variable %1 with const-qualified type %2|"
+  "cannot assign to %select{non-|}1static data member %2 "
+  "with const-qualified type %3|"
+  "cannot assign to non-static data member within const member function %1|"
+  "read-only variable is not assignable}0">;
+
+def note_typecheck_assign_const : Note<
+  "%select{"
+  "function %1 which returns const-qualified type %2 declared here|"
+  "variable %1 declared const here|"
+  "%select{non-|}1static data member %2 declared const here|"
+  "member function %q1 is declared const here}0">;
+
 def warn_mixed_sign_comparison : Warning<
   "comparison of integers of different signs: %0 and %1">,
   InGroup<SignCompare>, DefaultIgnore;
 def warn_lunsigned_always_true_comparison : Warning<
   "comparison of unsigned%select{| enum}2 expression %0 is always %1">,
   InGroup<TautologicalCompare>;
 def warn_out_of_range_compare : Warning<
   "comparison of %select{constant %0|true|false}1 with " 

cfe/trunk/lib/Sema/SemaExpr.cpp

while (DC != var->getDeclContext()) {
     DC = DC->getParent();
   }
   // Unless we have an init-capture, we've gone one step too far.
   if (!var->isInitCapture())
     DC = Prev;
   return (isa<BlockDecl>(DC) ? NCCK_Block : NCCK_Lambda);
 }
 
+static bool IsTypeModifiable(QualType Ty, bool IsDereference) {
+  Ty = Ty.getNonReferenceType();
+  if (IsDereference && Ty->isPointerType())
+    Ty = Ty->getPointeeType();
+  return !Ty.isConstQualified();
+}
+
+/// Emit the "read-only variable not assignable" error and print notes to give
+/// more information about why the variable is not assignable, such as pointing
+/// to the declaration of a const variable, showing that a method is const, or
+/// that the function is returning a const reference.
+static void DiagnoseConstAssignment(Sema &S, const Expr *E,
+                                    SourceLocation Loc) {
+  // Update err_typecheck_assign_const and note_typecheck_assign_const
+  // when this enum is changed.
+  enum {
+    ConstFunction,
+    ConstVariable,
+    ConstMember,
+    ConstMethod,
+    ConstUnknown,  // Keep as last element
+  };
+
+  SourceRange ExprRange = E->getSourceRange();
+
+  // Only emit one error on the first const found.  All other consts will emit
+  // a note to the error.
+  bool DiagnosticEmitted = false;
+
+  // Track if the current expression is the result of a derefence, and if the
+  // next checked expression is the result of a derefence.
+  bool IsDereference = false;
+  bool NextIsDereference = false;
+
+  // Loop to process MemberExpr chains.
+  while (true) {
+    IsDereference = NextIsDereference;
+    NextIsDereference = false;
+
+    E = E->IgnoreParenImpCasts();
+    if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
+      NextIsDereference = ME->isArrow();
+      const ValueDecl *VD = ME->getMemberDecl();
+      if (const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) {
+        // Mutable fields can be modified even if the class is const.
+        if (Field->isMutable()) {
+          assert(DiagnosticEmitted && "Expected diagnostic not emitted.");
+          break;
+        }
+
+        if (!IsTypeModifiable(Field->getType(), IsDereference)) {
+          if (!DiagnosticEmitted) {
+            S.Diag(Loc, diag::err_typecheck_assign_const)
+                << ExprRange << ConstMember << false /*static*/ << Field
+                << Field->getType();
+            DiagnosticEmitted = true;
+          }
+          S.Diag(VD->getLocation(), diag::note_typecheck_assign_const)
+              << ConstMember << false /*static*/ << Field << Field->getType()
+              << Field->getSourceRange();
+        }
+        E = ME->getBase();
+        continue;
+      } else if (const VarDecl *VDecl = dyn_cast<VarDecl>(VD)) {
+        if (VDecl->getType().isConstQualified()) {
+          if (!DiagnosticEmitted) {
+            S.Diag(Loc, diag::err_typecheck_assign_const)
+                << ExprRange << ConstMember << true /*static*/ << VDecl
+                << VDecl->getType();
+            DiagnosticEmitted = true;
+          }
+          S.Diag(VD->getLocation(), diag::note_typecheck_assign_const)
+              << ConstMember << true /*static*/ << VDecl << VDecl->getType()
+              << VDecl->getSourceRange();
+        }
+        // Static fields do not inherit constness from parents.
+        break;
+      }
+      break;
+    } // End MemberExpr
+    break;
+  }
+
+  if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
+    // Function calls
+    const FunctionDecl *FD = CE->getDirectCallee();
+    if (!IsTypeModifiable(FD->getReturnType(), IsDereference)) {
+      if (!DiagnosticEmitted) {
+        S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
+                                                      << ConstFunction << FD;
+        DiagnosticEmitted = true;
+      }
+      S.Diag(FD->getReturnTypeSourceRange().getBegin(),
+             diag::note_typecheck_assign_const)
+          << ConstFunction << FD << FD->getReturnType()
+          << FD->getReturnTypeSourceRange();
+    }
+  } else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
+    // Point to variable declaration.
+    if (const ValueDecl *VD = DRE->getDecl()) {
+      if (!IsTypeModifiable(VD->getType(), IsDereference)) {
+        if (!DiagnosticEmitted) {
+          S.Diag(Loc, diag::err_typecheck_assign_const)
+              << ExprRange << ConstVariable << VD << VD->getType();
+          DiagnosticEmitted = true;
+        }
+        S.Diag(VD->getLocation(), diag::note_typecheck_assign_const)
+            << ConstVariable << VD << VD->getType() << VD->getSourceRange();
+      }
+    }
+  } else if (isa<CXXThisExpr>(E)) {
+    if (const DeclContext *DC = S.getFunctionLevelDeclContext()) {
+      if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
+        if (MD->isConst()) {
+          if (!DiagnosticEmitted) {
+            S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
+                                                          << ConstMethod << MD;
+            DiagnosticEmitted = true;
+          }
+          S.Diag(MD->getLocation(), diag::note_typecheck_assign_const)
+              << ConstMethod << MD << MD->getSourceRange();
+        }
+      }
+    }
+  }
+
+  if (DiagnosticEmitted)
+    return;
+
+  // Can't determine a more specific message, so display the generic error.
+  S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange << ConstUnknown;
+}
+
 /// CheckForModifiableLvalue - Verify that E is a modifiable lvalue.  If not,
 /// emit an error and return true.  If so, return false.
 static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
   assert(!E->hasPlaceholderType(BuiltinType::PseudoObject));
   SourceLocation OrigLoc = Loc;
   Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context,
                                                               &Loc);
   if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S))
     IsLV = Expr::MLV_InvalidMessageExpression;
   if (IsLV == Expr::MLV_Valid)
     return false;
 
   unsigned DiagID = 0;
   bool NeedType = false;
   switch (IsLV) { // C99 6.5.16p2
   case Expr::MLV_ConstQualified:
-    DiagID = diag::err_typecheck_assign_const;
-
     // Use a specialized diagnostic when we're assigning to an object
     // from an enclosing function or block.
     if (NonConstCaptureKind NCCK = isReferenceToNonConstCapture(S, E)) {
       if (NCCK == NCCK_Block)
         DiagID = diag::err_block_decl_ref_not_modifiable_lvalue;
       else
         DiagID = diag::err_lambda_decl_ref_not_modifiable_lvalue;
       break;
if (S.getLangOpts().ObjCAutoRefCount) {
           //  - fast enumeration variables
           else
             DiagID = diag::err_typecheck_arr_assign_enumeration;
 
           SourceRange Assign;
           if (Loc != OrigLoc)
             Assign = SourceRange(OrigLoc, OrigLoc);
           S.Diag(Loc, DiagID) << E->getSourceRange() << Assign;
-          // We need to preserve the AST regardless, so migration tool 
+          // We need to preserve the AST regardless, so migration tool
           // can do its job.
           return false;
         }
       }
     }
 
+    // If none of the special cases above are triggered, then this is a
+    // simple const assignment.
+    if (DiagID == 0) {
+      DiagnoseConstAssignment(S, E, Loc);
+      return true;
+    }
+
     break;
   case Expr::MLV_ArrayType:
   case Expr::MLV_ArrayTemporary:
     DiagID = diag::err_typecheck_array_not_modifiable_lvalue;
     NeedType = true;
     break;
   case Expr::MLV_NotObjectType:
     DiagID = diag::err_typecheck_non_object_not_modifiable_lvalue;

cfe/trunk/test/CXX/temp/temp.decls/temp.mem/p5.cpp

 };
 
 template float Foo::As();
 template double Foo::As2();
 
 // Partial ordering with conversion function templates.
 struct X0 {
   template<typename T> operator T*() {
-    T x = 1;
-    x = 17; // expected-error{{read-only variable is not assignable}}
+    T x = 1; // expected-note{{variable 'x' declared const here}}
+    x = 17; // expected-error{{cannot assign to variable 'x' with const-qualified type 'const int'}}
   }
   
   template<typename T> operator T*() const; // expected-note{{explicit instantiation refers here}}
   
   template<typename T> operator const T*() const {
     T x = T();
     return x; // expected-error{{cannot initialize return object of type 'const char *' with an lvalue of type 'char'}} \
     // expected-error{{cannot initialize return object of type 'const int *' with an lvalue of type 'int'}}

cfe/trunk/test/Sema/anonymous-struct-union.c

struct X {
 
   struct {
     int a;
     float b;
   };
 };
 
 void test_unqual_references(struct X x, const struct X xc) {
+  // expected-note@-1 3{{variable 'xc' declared const here}}
   x.i = 0;
   x.f = 0.0;
   x.f2 = x.f;
   x.d = x.f;
   x.f3 = 0; // expected-error{{no member named 'f3'}}
   x.a = 0;
 
-  xc.d = 0.0; // expected-error{{read-only variable is not assignable}}
-  xc.f = 0; // expected-error{{read-only variable is not assignable}}
-  xc.a = 0; // expected-error{{read-only variable is not assignable}}
+  xc.d = 0.0; // expected-error{{cannot assign to variable 'xc' with const-qualified type 'const struct X'}}
+  xc.f = 0; // expected-error{{cannot assign to variable 'xc' with const-qualified type 'const struct X'}}
+  xc.a = 0; // expected-error{{cannot assign to variable 'xc' with const-qualified type 'const struct X'}}
 }
 
 
 struct Redecl {
   int x; // expected-note{{previous declaration is here}}
   struct y { }; // expected-warning{{declaration does not declare anything}}
 
   union {

cfe/trunk/test/Sema/assign.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 void *test1(void) { return 0; }
 
 void test2 (const struct {int a;} *x) {
-  x->a = 10; // expected-error {{read-only variable is not assignable}}
+  // expected-note@-1 {{variable 'x' declared const here}}
+
+  x->a = 10;
+  // expected-error-re@-1 {{cannot assign to variable 'x' with const-qualified type 'const struct (anonymous struct at {{.*}}assign.c:5:19) *'}}
 }
 
 typedef int arr[10];
 void test3() {
   const arr b;
   const int b2[10]; 
   b[4] = 1; // expected-error {{read-only variable is not assignable}}
   b2[4] = 1; // expected-error {{read-only variable is not assignable}}
 }

cfe/trunk/test/Sema/block-misc.c

void test17() {
   (void)(0 == bp);
   (void)(bp < 1); // expected-error {{invalid operands to binary expression}}
   (void)(bp < 0); // expected-error {{invalid operands to binary expression}}
   (void)(1 < bp); // expected-error {{invalid operands to binary expression}}
   (void)(0 < bp); // expected-error {{invalid operands to binary expression}}
 }
 
 void test18() {
-  void (^const  blockA)(void) = ^{ };
-  blockA = ^{ }; // expected-error {{read-only variable is not assignable}}
+  void (^const  blockA)(void) = ^{ };  // expected-note {{variable 'blockA' declared const here}}
+  blockA = ^{ }; // expected-error {{cannot assign to variable 'blockA' with const-qualified type 'void (^const)(void)}}
 }
 
 // rdar://7072507
 int test19() {
   goto L0;       // expected-error {{cannot jump}}
   
   __block int x; // expected-note {{jump bypasses setup of __block variable}}
 L0:

cfe/trunk/test/SemaCXX/anonymous-union.cpp

void X::test_unqual_references() {
   i = 0;
   f = 0.0;
   f2 = f;
   d = f;
   f3 = 0; // expected-error{{use of undeclared identifier 'f3'}}
   a = 0;
 }
 
-void X::test_unqual_references_const() const {
+void X::test_unqual_references_const() const { // expected-note 2{{member function 'X::test_unqual_references_const' is declared const here}}
   d = 0.0;
-  f2 = 0; // expected-error{{read-only variable is not assignable}}
-  a = 0; // expected-error{{read-only variable is not assignable}}
+  f2 = 0; // expected-error{{cannot assign to non-static data member within const member function 'test_unqual_references_const'}}
+  a = 0; // expected-error{{cannot assign to non-static data member within const member function 'test_unqual_references_const'}}
 }
 
 void test_unqual_references(X x, const X xc) {
+  // expected-note@-1 2{{variable 'xc' declared const here}}
   x.i = 0;
   x.f = 0.0;
   x.f2 = x.f;
   x.d = x.f;
   x.f3 = 0; // expected-error{{no member named 'f3'}}
   x.a = 0;
 
   xc.d = 0.0;
-  xc.f = 0; // expected-error{{read-only variable is not assignable}}
-  xc.a = 0; // expected-error{{read-only variable is not assignable}}
+  xc.f = 0; // expected-error{{cannot assign to variable 'xc' with const-qualified type 'const X'}}
+  xc.a = 0; // expected-error{{cannot assign to variable 'xc' with const-qualified type 'const X'}}
 }
 
 
 struct Redecl {
   int x; // expected-note{{previous declaration is here}}
   class y { };
 
   union {

cfe/trunk/test/SemaCXX/captured-statements.cpp

void test_capture_var() {
   template_capture_var<int>(); // OK
   template_capture_var<int&>(); // expected-note{{in instantiation of function template specialization 'template_capture_var<int &>' requested here}}
 
   Val<float> Obj;
   Obj.set(0.0f); // OK
 }
 
 template <typename S, typename T>
-S template_capture_var(S x, T y) {
+S template_capture_var(S x, T y) {  // expected-note{{variable 'y' declared const here}}
   #pragma clang _debug captured
   {
     x++;
-    y++;  // expected-error{{read-only variable is not assignable}}
+    y++;  // expected-error{{cannot assign to variable 'y' with const-qualified type 'const int'}}
   }
 
   return x;
 }
 
 // Check if can recover from a template error.
 void test_capture_var_error() {
   template_capture_var<int, int>(0, 1); // OK

cfe/trunk/test/SemaCXX/cxx0x-constexpr-const.cpp

 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
 
-constexpr int x = 1;
+constexpr int x = 1;  // expected-note {{variable 'x' declared const here}}
 constexpr int id(int x) { return x; }
 
 void foo(void) {
-  x = 2; // expected-error {{read-only variable is not assignable}}
+  x = 2; // expected-error {{cannot assign to variable 'x' with const-qualified type 'const int'}}
   int (*idp)(int) = id;
 }
 

cfe/trunk/test/SemaCXX/err_typecheck_assign_const.cpp

+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
+
+const int global = 5;  // expected-note{{variable 'global' declared const here}}
+void test1() {
+  global = 2;  // expected-error{{cannot assign to variable 'global' with const-qualified type 'const int'}}
+}
+
+void test2 () {
+  const int local = 5;  // expected-note{{variable 'local' declared const here}}
+  local = 0;  // expected-error{{cannot assign to variable 'local' with const-qualified type 'const int'}}
+}
+
+void test2 (const int parameter) {  // expected-note{{variable 'parameter' declared const here}}
+  parameter = 2;  // expected-error{{cannot assign to variable 'parameter' with const-qualified type 'const int'}}
+}
+
+class test3 {
+  int field;
+  const int const_field = 1;  // expected-note 2{{non-static data member 'const_field' declared const here}}
+  static const int static_const_field = 1;  // expected-note 2{{variable 'static_const_field' declared const here}}
+  void test() {
+    const_field = 4;  // expected-error{{cannot assign to non-static data member 'const_field' with const-qualified type 'const int'}}
+    static_const_field = 4;  // expected-error{{cannot assign to variable 'static_const_field' with const-qualified type 'const int'}}
+  }
+  void test_const() const { // expected-note 2{{member function 'test3::test_const' is declared const here}}
+    field = 4;  // expected-error{{cannot assign to non-static data member within const member function 'test_const'}}
+    const_field = 4 ;  // expected-error{{cannot assign to non-static data member 'const_field' with const-qualified type 'const int'}}
+    static_const_field = 4;  // expected-error{{cannot assign to variable 'static_const_field' with const-qualified type 'const int'}}
+  }
+};
+
+const int &return_const_ref();  // expected-note{{function 'return_const_ref' which returns const-qualified type 'const int &' declared here}}
+
+void test4() {
+  return_const_ref() = 10;  // expected-error{{cannot assign to return value because function 'return_const_ref' returns a const value}}
+}
+
+struct S5 {
+  int field;
+  const int const_field = 4;  // expected-note {{non-static data member 'const_field' declared const here}}
+};
+
+void test5() {
+  S5 s5;
+  s5.field = 5;
+  s5.const_field = 5;  // expected-error{{cannot assign to non-static data member 'const_field' with const-qualified type 'const int'}}
+}
+
+struct U1 {
+  int a = 5;
+};
+
+struct U2 {
+  U1 u1;
+};
+
+struct U3 {
+  const U2 u2 = U2();  // expected-note{{non-static data member 'u2' declared const here}}
+};
+
+struct U4 {
+  U3 u3;
+};
+
+void test6() {
+  U4 u4;
+  u4.u3.u2.u1.a = 5;  // expected-error{{cannot assign to non-static data member 'u2' with const-qualified type 'const U2'}}
+}
+
+struct A {
+  int z;
+};
+struct B {
+  A a;
+};
+struct C {
+  B b;
+  C();
+};
+const C &getc(); // expected-note{{function 'getc' which returns const-qualified type 'const C &' declared here}}
+void test7() {
+  const C c;    // expected-note{{variable 'c' declared const here}}
+  c.b.a.z = 5;  // expected-error{{cannot assign to variable 'c' with const-qualified type 'const C'}}
+
+  getc().b.a.z = 5;  // expected-error{{cannot assign to return value because function 'getc' returns a const value}}
+}
+
+struct D { const int n; };  // expected-note 2{{non-static data member 'n' declared const here}}
+struct E { D *const d = 0; };
+void test8() {
+  extern D *const d;
+  d->n = 0;  // expected-error{{cannot assign to non-static data member 'n' with const-qualified type 'const int'}}
+
+  E e;
+  e.d->n = 0;  // expected-error{{cannot assign to non-static data member 'n' with const-qualified type 'const int'}}
+}
+
+struct F { int n; };
+struct G { const F *f; };  // expected-note{{non-static data member 'f' declared const here}}
+void test10() {
+  const F *f;  // expected-note{{variable 'f' declared const here}}
+  f->n = 0;    // expected-error{{cannot assign to variable 'f' with const-qualified type 'const F *'}}
+
+  G g;
+  g.f->n = 0;  // expected-error{{cannot assign to non-static data member 'f' with const-qualified type 'const F *'}}
+}
+
+void test11(
+    const int x,  // expected-note{{variable 'x' declared const here}}
+    const int& y  // expected-note{{variable 'y' declared const here}}
+    ) {
+  x = 5;  // expected-error{{cannot assign to variable 'x' with const-qualified type 'const int'}}
+  y = 5;  // expected-error{{cannot assign to variable 'y' with const-qualified type 'const int &'}}
+}
+
+struct H {
+  const int a = 0;   // expected-note{{non-static data member 'a' declared const here}}
+  const int &b = a;  // expected-note{{non-static data member 'b' declared const here}}
+};
+
+void test12(H h) {
+  h.a = 1;  // expected-error {{cannot assign to non-static data member 'a' with const-qualified type 'const int'}}
+  h.b = 2;  // expected-error {{cannot assign to non-static data member 'b' with const-qualified type 'const int &'}}
+}

cfe/trunk/test/SemaCXX/err_typecheck_assign_const_filecheck.cpp

+// RUN: not %clang_cc1 -fsyntax-only -std=c++11 %s 2>&1 | FileCheck %s
+
+struct E {
+  int num;
+  const int Cnum = 0;
+  mutable int Mnum;
+  static int Snum;
+  const static int CSnum;
+};
+
+struct D {
+  E e;
+  const E Ce;
+  mutable E Me;
+  static E Se;
+  const static E CSe;
+  E &getE() const;
+  const E &getCE() const;
+};
+
+struct C {
+  D d;
+  const D Cd;
+  mutable D Md;
+  static D Sd;
+  const static D CSd;
+  D &getD() const;
+  const D &getCD() const;
+};
+
+struct B {
+  C c;
+  const C Cc;
+  mutable C Mc;
+  static C Sc;
+  const static C CSc;
+  C &getC() const;
+  static C &getSC();
+  const C &getCC() const;
+  static const C &getSCC();
+};
+
+struct A {
+  B b;
+  const B Cb;
+  mutable B Mb;
+  static B Sb;
+  const static B CSb;
+  B &getB() const;
+  static B &getSB();
+  const B &getCB() const;
+  static const B &getSCB();
+};
+
+A& getA();
+
+// Valid assignment
+void test1(A a, const A Ca) {
+  a.b.c.d.e.num = 5;
+  a.b.c.d.e.Mnum = 5;
+  Ca.b.c.d.e.Mnum = 5;
+  a.b.c.d.e.Snum = 5;
+  Ca.b.c.d.e.Snum = 5;
+  Ca.b.c.Md.e.num = 5;
+  Ca.Mb.Cc.d.e.Mnum = 5;
+  Ca.Mb.getC().d.e.num = 5;
+  Ca.getSB().c.d.e.num = 5;
+  a.getSCB().c.d.Me.num = 5;
+  Ca.Cb.Cc.Cd.Ce.Snum = 5;
+  // CHECK-NOT: error:
+  // CHECK-NOT: note:
+}
+
+// One note
+void test2(A a, const A Ca) {
+  Ca.b.c.d.e.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Ca'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Ca'
+  // CHECK-NOT: note:
+
+  a.Cb.c.d.e.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Cb'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Cb'
+  // CHECK-NOT: note:
+
+  a.b.c.Cd.e.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Cd'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Cd'
+  // CHECK-NOT: note:
+
+  a.b.c.d.e.CSnum = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'CSnum'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'CSnum'
+  // CHECK-NOT: note:
+
+  a.b.c.d.e.Cnum = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Cnum'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Cnum'
+  // CHECK-NOT: note:
+
+  a.getCB().c.d.e.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'getCB'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'getCB'
+  // CHECK-NOT: note:
+
+  a.getSCB().c.d.e.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'getSCB'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'getSCB'
+  // CHECK-NOT: note:
+}
+
+// Two notes
+void test3(A a, const A Ca) {
+
+  a.getSCB().Cc.d.e.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Cc'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Cc'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'getSCB'
+  // CHECK-NOT: note:
+
+  Ca.b.c.Cd.e.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Cd'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Cd'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Ca'
+  // CHECK-NOT: note:
+
+  a.getCB().c.Cd.e.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Cd'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Cd'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'getCB'
+  // CHECK-NOT: note:
+
+  a.b.getCC().d.e.Cnum = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Cnum'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Cnum'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'getCC'
+  // CHECK-NOT: note:
+
+  a.b.c.Cd.Ce.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Ce'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Ce'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Cd'
+  // CHECK-NOT: note:
+
+  a.b.CSc.Cd.e.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Cd'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Cd'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'CSc'
+  // CHECK-NOT: note:
+
+  a.CSb.c.Cd.e.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Cd'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Cd'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'CSb'
+  // CHECK-NOT: note:
+}
+
+// No errors
+void test4(const A Ca) {
+  // Mutable cases
+  Ca.Mb.c.d.e.num = 5;
+  Ca.CSb.Mc.d.e.num = 5;
+  Ca.getCB().Mc.d.e.num = 5;
+  Ca.getSCB().Mc.d.e.num = 5;
+
+  // Returning non-const reference
+  Ca.getB().c.d.e.num = 5;
+  Ca.CSb.getC().d.e.num = 5;
+  Ca.getCB().getC().d.e.num = 5;
+  Ca.getSCB().getC().d.e.num = 5;
+
+  // Returning non-const reference
+  Ca.getSB().c.d.e.num = 5;
+  Ca.CSb.getSC().d.e.num = 5;
+  Ca.getCB().getSC().d.e.num = 5;
+  Ca.getSCB().getSC().d.e.num = 5;
+
+  // Static member
+  Ca.Sb.c.d.e.num = 5;
+  Ca.CSb.Sc.d.e.num = 5;
+  Ca.getCB().Sc.d.e.num = 5;
+  Ca.getSCB().Sc.d.e.num = 5;
+
+  // CHECK-NOT: error:
+  // CHECK-NOT: note:
+}
+
+// Only display notes for relavent cases.
+void test5(const A Ca) {
+  Ca.Mb.c.d.Ce.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Ce'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Ce'
+  // CHECK-NOT: note:
+
+  Ca.getB().c.d.Ce.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Ce'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Ce'
+  // CHECK-NOT: note:
+
+  Ca.getSB().c.d.Ce.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Ce'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Ce'
+  // CHECK-NOT: note:
+
+  Ca.Sb.c.d.Ce.num = 5;
+  // CHECK-NOT: error:
+  // CHECK: error:{{.*}} 'Ce'
+  // CHECK-NOT: note:
+  // CHECK: note:{{.*}} 'Ce'
+  // CHECK-NOT: note:
+}

cfe/trunk/test/SemaCXX/function-type-qual.cpp

class C {
   cfn f2;
   static void f3() const; // expected-error {{static member function cannot have 'const' qualifier}}
   static cfn f4; // expected-error {{static member function of type 'cfn' (aka 'void () const') cannot have 'const' qualifier}}
 
   void m1() {
     x = 0;
   }
 
-  void m2() const {
-    x = 0; // expected-error {{read-only variable is not assignable}}
+  void m2() const { // expected-note {{member function 'C::m2' is declared const here}}
+    x = 0; // expected-error {{cannot assign to non-static data member within const member function 'm2'}}
   }
 
   int x;
 };
 
 void (C::*mpf)() const;
 cfn C::*mpg;
 

cfe/trunk/test/SemaObjC/arc.m

void test11(id op, void *vp) {
   b = (op == vp);
 }
 
 void test12(id collection) {
   for (id x in collection) {
     x = 0; // expected-error {{fast enumeration variables can't be modified in ARC by default; declare the variable __strong to allow this}}
   }
 
-  for (const id x in collection) {
-    x = 0; // expected-error {{read-only variable is not assignable}}
+  for (const id x in collection) { // expected-note {{variable 'x' declared const here}}
+    x = 0; // expected-error {{cannot assign to variable 'x' with const-qualified type 'const __strong id'}}
   }
 
   for (__strong id x in collection) {
     x = 0;
   }
 }
 
 @interface Test13

cfe/trunk/test/SemaTemplate/dependent-type-identity.cpp

template<typename T> struct A {
     void h(const T);
     void i(T);
   };
 
   template<typename T>
   void A<T>::f(int x) { x = 0; }
 
   template<typename T>
-  void A<T>::g(const int x) { x = 0; } // expected-error {{not assignable}}
+  void A<T>::g(const int x) {  // expected-note {{declared const here}}
+    x = 0; // expected-error {{cannot assign to variable 'x'}}
+  }
 
   template<typename T>
   void A<T>::h(T) {} // FIXME: Should reject this. Type is different from prior decl if T is an array type.
 
   template<typename T>
   void A<T>::i(const T) {} // FIXME: Should reject this. Type is different from prior decl if T is an array type.
 
   template struct A<int>;