Commit Graph

62 Commits

Author SHA1 Message Date
Anders Carlsson a42ab8f3d5 Handle temporaries in default arguments.
llvm-svn: 73462
2009-06-16 03:37:31 +00:00
Douglas Gregor 8cfd2ba76d Diagnose the incorrect use of non-type template arguments for class
template partial specializations.

llvm-svn: 73254
2009-06-12 21:21:02 +00:00
Anders Carlsson 0880e9f58d Instantiation support for more Obj-C expressions, string literals, @selector and @protocol expressions.
llvm-svn: 73036
2009-06-07 19:51:47 +00:00
Anders Carlsson 315d2294f8 Template instantiation support for Obj-C @encode expressions.
llvm-svn: 73034
2009-06-07 18:45:35 +00:00
Douglas Gregor b7ae10f764 Several improvements to template argument deduction:
- Once we have deduced template arguments for a class template partial
    specialization, we use exactly those template arguments for instantiating
    the definition of the class template partial specialization.
  - Added template argument deduction for non-type template parameters.
  - Added template argument deduction for dependently-sized array types.

With these changes, we can now implement, e.g., the remove_reference
type trait. Also, Daniel's Ackermann template metaprogram now compiles
properly.

llvm-svn: 72909
2009-06-05 00:53:49 +00:00
Anders Carlsson 4b2434da54 Remove VarDecl from CXXConstructExpr.
llvm-svn: 72633
2009-05-30 20:56:46 +00:00
Anders Carlsson b228818554 Bind temporaries correctly when instantiating expressions.
llvm-svn: 72632
2009-05-30 20:52:37 +00:00
Anders Carlsson 993a4b3080 Add a CXXBindTemporaryExpr.
llvm-svn: 72627
2009-05-30 20:03:25 +00:00
Douglas Gregor 6181ded4ad Reduce the amount of stack space we use in SmallVectors during
template instantiation. This helps reduce our stack footprint when
performing deep template instantiations.

llvm-svn: 72582
2009-05-29 18:27:38 +00:00
Douglas Gregor cd3a097925 Simplify, and improve the performance of, template instantiation for
declaration references. The key realization is that dependent Decls,
which actually require instantiation, can only refer to the current
instantiation or members thereof. And, since the current context
during instantiation contains all of those members of the current
instantiation, we can simply find the real instantiate that matches up
with the "current instantiation" template.

llvm-svn: 72486
2009-05-27 17:54:46 +00:00
Douglas Gregor f98d9b60db Improve name lookup for and template instantiation of declaration
references. There are several smallish fixes here:

  - Make sure we look through template parameter scope when
    determining whether we're parsing a nested class (or nested class
    *template*). This makes sure that we delay parsing the bodies of
    inline member functions until after we're out of the outermost
    class (template) scope.
  - Since the bodies of member functions are always parsed
    "out-of-line", even when they were declared in-line, teach
    unqualified name lookup to look into the (semantic) parents.
  - Use the new InstantiateDeclRef to handle the instantiation of a
    reference to a declaration (in DeclRefExpr), which drastically
    simplifies template instantiation for DeclRefExprs.
  - When we're instantiating a ParmVarDecl, it must be in the current
    instantiation scope, so only look there.

Also, remove the #if 0's and FIXME's from the dynarray example, which
now compiles and executes thanks to Anders and Eli.

llvm-svn: 72481
2009-05-27 17:07:49 +00:00
Douglas Gregor 5178331379 Initial stab at a generalized operation for determining the
instantiation of a declaration from the template version (or version
that lives in a template) and a given set of template arguments. This
needs much, much more testing, but it suffices for simple examples
like

  typedef T* iterator;
  iterator begin();

llvm-svn: 72461
2009-05-27 05:35:12 +00:00
Douglas Gregor 408c619afc Template instantiation for "typeof" for both types and expressions.
llvm-svn: 72440
2009-05-26 22:09:24 +00:00
Douglas Gregor 4a9f481db9 Template instantiation for qualified declaration reference
expressions. We are now missing template instantiation logic for only
three classes of expressions:
  - Blocks-related expressions (BlockExpr, BlockDeclRefExpr)
  - C++ default argument expressions
  - Objective-C expressions

Additionally, our handling of DeclRefExpr is still quite poor, since
it cannot handle references to many kinds of declarations.

As part of this change, converted the TemplateExprInstantiator to use
iteration through all of the expressions via clang/AST/StmtNodes.def,
ensuring that we don't forget to add template instantiation logic for
any new expression node kinds.

llvm-svn: 72303
2009-05-22 23:47:06 +00:00
Douglas Gregor 93fcf93bc6 Template instantiation for the GNU address-of-label extension.
llvm-svn: 72301
2009-05-22 23:25:52 +00:00
Douglas Gregor 36fe6901d4 Template instantiation for ExtVectorElementExpr.
llvm-svn: 72299
2009-05-22 23:07:44 +00:00
Douglas Gregor efe7c393e1 Add a few tests to ensure that member functions of class templates can
call other member functions of class templates, including after
template instantiation. No functionality change.

llvm-svn: 72282
2009-05-22 21:26:58 +00:00
Douglas Gregor a8db954f24 Representation of and template instantiation for member
expressions. This change introduces another AST node,
CXXUnresolvedMemberExpr, that captures member references (x->m, x.m)
when the base of the expression (the "x") is type-dependent, and we
therefore cannot resolve the member reference yet.

Note that our parsing of member references for C++ is still quite
poor, e.g., we don't handle x->Base::m or x->operator int.

llvm-svn: 72281
2009-05-22 21:13:27 +00:00
Douglas Gregor 1c37d9eed5 Template instantiation for C99 compound literals
llvm-svn: 72236
2009-05-21 23:48:18 +00:00
Douglas Gregor 0f9d4003df Template instantiation for GNU array-range designators.
llvm-svn: 72234
2009-05-21 23:30:39 +00:00
Douglas Gregor ca1aeecd37 Template instantiation for C99 designated initializers, because we
can. Also, delay semantic analysis of initialization for
value-dependent as well as type-dependent expressions, since we can't
always properly type-check a value-dependent expression.

llvm-svn: 72233
2009-05-21 23:17:49 +00:00
Douglas Gregor c2607b9a08 Template instantiation for initializer lists
llvm-svn: 72229
2009-05-21 21:38:12 +00:00
Douglas Gregor 31c7e99401 Template instantiation for unary type traits, e.g., __is_pod
llvm-svn: 72220
2009-05-21 18:55:48 +00:00
Douglas Gregor aa85d8221c Template instantiation for C++ "typeid" expressions.
llvm-svn: 72218
2009-05-21 18:34:44 +00:00
Douglas Gregor 728d41bbb9 Template instantiation for C++ throw expressions
llvm-svn: 72217
2009-05-21 17:37:52 +00:00
Douglas Gregor 29fe6aeef3 Template instantiation for C++ delete expression
llvm-svn: 72216
2009-05-21 17:21:12 +00:00
Douglas Gregor 269f0b1b69 Merge the ASTVector and ASTOwningVector templates, since they offered
redundant functionality. The result (ASTOwningVector) lives in
clang/Parse/Ownership.h and is used by both the parser and semantic
analysis. No intended functionality change.

llvm-svn: 72214
2009-05-21 16:25:11 +00:00
Douglas Gregor d0fefbafd1 Template instantiation for C++ "new" expressions.
llvm-svn: 72199
2009-05-21 00:00:09 +00:00
Douglas Gregor 920e3af495 Fix template instantiation for compound statements so that it properly
passes the "isStmtExpr" flag, to suppress warnings about unused
expressions.

llvm-svn: 72190
2009-05-20 22:57:03 +00:00
Douglas Gregor 1301fdd6c4 Introduce a new kind of RAII class, ASTOwningVector, which is an
llvm::SmallVector that owns all of the AST nodes inside of it. This
RAII class is used to ensure proper destruction of AST nodes when
template instantiation fails.

llvm-svn: 72186
2009-05-20 22:33:37 +00:00
Douglas Gregor 06555f134a Template instantiation for CXXExprWithTemporaries, which occurs when
temporaries are generated for some object-constructing expressions in
templates that are not type-dependent. 

Also, be sure to introduce the variable from a CXXConditionDeclExpr
into the set of instantiated local variables.

llvm-svn: 72185
2009-05-20 21:51:01 +00:00
Douglas Gregor e70f108158 Template instantiation for the various kinds of AST nodes that occur
due to C++ type construction of the form T(a1, a2, ..., aN).

llvm-svn: 72183
2009-05-20 21:38:11 +00:00
Douglas Gregor ce934146d0 Introduce a new expression type, CXXUnresolvedConstructExpr, to
describe the construction of a value of a given type using function
syntax, e.g.,
  
  T(a1, a2, ..., aN)

when the type or any of its arguments are type-dependent. In this
case, we don't know what kind of type-construction this will be: it
might construct a temporary of type 'T' (which might be a class or
non-class type) or might perform a conversion to type 'T'. Also,
implement printing of and template instantiation for this new
expression type. Due to the change in Sema::ActOnCXXTypeConstructExpr,
our existing tests cover template instantiation of this new expression
node.

llvm-svn: 72176
2009-05-20 18:46:25 +00:00
Douglas Gregor 68f1096212 Add FIXMEs for the remaining C and C++ expression types that still
need template instantiation logic. Remove one FIXME by instantiating
the callee in a non-type-dependent CXXOperatorCallExpr.

llvm-svn: 72145
2009-05-19 23:29:16 +00:00
Douglas Gregor ad3150cd38 Template instantiation for __builtin_va_arg.
llvm-svn: 72144
2009-05-19 23:10:31 +00:00
Douglas Gregor 0df91121ba Template instantiation for __builtin_choose_expr.
llvm-svn: 72143
2009-05-19 22:43:30 +00:00
Douglas Gregor f907cbf634 Ban the use of __builtin_types_compatible_p in C++; g++ doesn't support it,
and it isn't clear exactly what it's supposed to mean. Thanks Eli!

llvm-svn: 72142
2009-05-19 22:28:02 +00:00
Douglas Gregor c25f766065 Template instantiation for __builtin_shufflevector.
llvm-svn: 72139
2009-05-19 22:10:17 +00:00
Douglas Gregor 4b58ca02c5 Template instantiation for __builtin_types_compatible_p.
llvm-svn: 72134
2009-05-19 20:55:31 +00:00
Douglas Gregor 8d7fef3cf2 Template instantiation for GNU statement expressions
llvm-svn: 72129
2009-05-19 20:31:21 +00:00
Douglas Gregor 115652db4a Fix handling of the GNU "t ? : f" extension to the conditional
operator in C++, and verify that template instantiation for the
condition operator does the right thing.

llvm-svn: 72127
2009-05-19 20:13:50 +00:00
Douglas Gregor 3234db1e13 Template instantiation for compound assignment operators.
llvm-svn: 72126
2009-05-19 20:02:01 +00:00
Douglas Gregor 71b6a37bc4 Template instantiation for cast expressions.
llvm-svn: 72119
2009-05-19 19:05:47 +00:00
Douglas Gregor be81045db7 Template instantiation for call expressions.
llvm-svn: 72081
2009-05-19 00:38:01 +00:00
Douglas Gregor 7a77a6bcf9 Template instantiation for array subscript expressions. This was far
easier than expected because of the limitation that subscript
operators must be member functions.

llvm-svn: 72076
2009-05-19 00:01:19 +00:00
Douglas Gregor 38e7f8bd6d Template instantiation for imaginary literals, because they were next in Expr.h
llvm-svn: 72058
2009-05-18 22:38:38 +00:00
Sebastian Redl e769ecf8ab Implement instantiation of a few boring, simple expressions. I don't think these are testable yet, though.
llvm-svn: 71953
2009-05-16 18:50:46 +00:00
Mike Stump 87c57acfb7 Reflow some comments.
llvm-svn: 71936
2009-05-16 07:39:55 +00:00
Douglas Gregor 8a930c3b73 Template instantiation for WhileStmt and CXXConditionDeclExpr.
llvm-svn: 71896
2009-05-15 21:45:53 +00:00
Douglas Gregor 3f17b47c7e Allow instantiation of NULL expressions and statements
llvm-svn: 71889
2009-05-15 20:47:12 +00:00