llvm-svn: 61002

llvm-svn: 60864

llvm-svn: 60819

llvm-svn: 60763

llvm-svn: 60699

llvm-svn: 60425

llvm-svn: 60413

llvm-svn: 60029

llvm-svn: 59735

being called to be converted to a reference-to-function,
pointer-to-function, or reference-to-pointer-to-function. This is done
through "surrogate" candidate functions that model the conversions
from the object to the function (reference/pointer) and the
conversions in the arguments.

llvm-svn: 59674

with function call syntax, e.g.,

  Functor f;
  f(x, y);

This is the easy part of handling calls to objects of class type 
(C++ [over.call.object]). The hard part (coping with conversions from
f to function pointer or reference types) will come later. Nobody uses
that stuff anyway, right? :)

llvm-svn: 59663

built-in operator candidates. Test overloading of '&' and ','.

In C++, a comma expression is an lvalue if its right-hand
subexpression is an lvalue. Update Expr::isLvalue accordingly.

llvm-svn: 59643

post-decrement, including support for generating all of the built-in
operator candidates for these operators. 

C++ and C have different rules for the arguments to the builtin unary
'+' and '-'. Implemented both variants in Sema::ActOnUnaryOp.

In C++, pre-increment and pre-decrement return lvalues. Update
Expr::isLvalue accordingly.

llvm-svn: 59638

llvm-svn: 59591

suite with clang.

llvm-svn: 59536

llvm-svn: 59503

llvm-svn: 59457

llvm-svn: 59353

Thanks to Doug for the review. Actual effects of mutable to follow.

llvm-svn: 59331

llvm-svn: 59272

developing clang.

llvm-svn: 59270

llvm-svn: 59209

llvm-svn: 59206

llvm-svn: 59195

llvm-svn: 59042

llvm-svn: 59000

llvm-svn: 58932

Update C++ status to reflect parser capabilities for chapter 9 (classes). Slightly extend the class parser test.

llvm-svn: 58909

llvm-svn: 58907

llvm-svn: 58867

llvm-svn: 58864

llvm-svn: 58862

operators. For example, one can now write "x + y" where x or y is a
class or enumeration type, and Clang will perform overload resolution
for "+" based on the overloaded operators it finds.

The other kinds of overloadable operators in C++ will follow this same
approach. 

Three major issues remain:
  1) We don't find member operators
  2) Since we don't have user-defined conversion operators, we can't
  call any of the built-in overloaded operators in C++ [over.built].
  3) Once we've done the semantic checks, we drop the overloaded
  operator on the floor; it doesn't get into the AST at all.

llvm-svn: 58821

operators in C++. Overloaded operators can be called directly via
their operator-function-ids, e.g., "operator+(foo, bar)", but we don't
yet implement the semantics of operator overloading to handle, e.g.,
"foo + bar".

llvm-svn: 58817

llvm-svn: 58776

Implicit declaration of destructors (when necessary).

Extended Declarator to store information about parsed constructors
and destructors; this will be extended to deal with declarators that
name overloaded operators (e.g., "operator +") and user-defined
conversion operators (e.g., "operator int").

llvm-svn: 58767

for constructor initializations, e.g.,

  class A { };
  class B : public A { 
    int m;
  public:
    B() : A(), m(17) { };
  };

llvm-svn: 58749

llvm-svn: 58713

llvm-svn: 58699

llvm-svn: 58672