From 222e2a7620e6520ffaf4fc4e69d79c18da31542e Mon Sep 17 00:00:00 2001
From: "Zancanaro; Carlo" <czan8762@plang3.cs.usyd.edu.au>
Date: Mon, 24 Sep 2012 09:58:17 +1000
Subject: Add the clang library to the repo (with some of my changes, too).

---
 clang/test/SemaTemplate/ackermann.cpp              |  38 +++
 clang/test/SemaTemplate/address-spaces.cpp         |  86 +++++
 clang/test/SemaTemplate/alias-church-numerals.cpp  |  34 ++
 clang/test/SemaTemplate/alias-nested-nontag.cpp    |   6 +
 .../SemaTemplate/alias-template-template-param.cpp |   7 +
 clang/test/SemaTemplate/alias-templates.cpp        | 102 ++++++
 clang/test/SemaTemplate/ambiguous-ovl-print.cpp    |   9 +
 clang/test/SemaTemplate/anonymous-union.cpp        |  40 +++
 clang/test/SemaTemplate/array-to-pointer-decay.cpp |  25 ++
 clang/test/SemaTemplate/atomics.cpp                |  16 +
 clang/test/SemaTemplate/attributes.cpp             |  34 ++
 clang/test/SemaTemplate/canonical-expr-type-0x.cpp |  25 ++
 clang/test/SemaTemplate/canonical-expr-type.cpp    |  53 +++
 .../class-template-ctor-initializer.cpp            |  55 ++++
 clang/test/SemaTemplate/class-template-decl.cpp    |  97 ++++++
 clang/test/SemaTemplate/class-template-id-2.cpp    |  24 ++
 clang/test/SemaTemplate/class-template-id.cpp      |  47 +++
 clang/test/SemaTemplate/class-template-spec.cpp    | 121 +++++++
 clang/test/SemaTemplate/constexpr-instantiate.cpp  |  77 +++++
 clang/test/SemaTemplate/constructor-template.cpp   | 128 ++++++++
 clang/test/SemaTemplate/copy-ctor-assign.cpp       |  52 +++
 clang/test/SemaTemplate/crash-10438657.cpp         |  15 +
 clang/test/SemaTemplate/crash-8204126.cpp          |   6 +
 clang/test/SemaTemplate/current-instantiation.cpp  | 237 ++++++++++++++
 clang/test/SemaTemplate/deduction-crash.cpp        |  89 +++++
 clang/test/SemaTemplate/deduction.cpp              | 164 ++++++++++
 .../test/SemaTemplate/default-arguments-cxx0x.cpp  |  26 ++
 clang/test/SemaTemplate/default-arguments.cpp      | 138 ++++++++
 .../test/SemaTemplate/default-expr-arguments-2.cpp |  19 ++
 clang/test/SemaTemplate/default-expr-arguments.cpp | 305 +++++++++++++++++
 .../test/SemaTemplate/delegating-constructors.cpp  |  31 ++
 clang/test/SemaTemplate/dependent-base-classes.cpp | 137 ++++++++
 .../SemaTemplate/dependent-base-member-init.cpp    |  68 ++++
 .../dependent-class-member-operator.cpp            |  11 +
 clang/test/SemaTemplate/dependent-expr.cpp         |  73 +++++
 clang/test/SemaTemplate/dependent-names-no-std.cpp |  21 ++
 clang/test/SemaTemplate/dependent-names.cpp        | 326 ++++++++++++++++++
 clang/test/SemaTemplate/dependent-sized_array.cpp  |  17 +
 .../SemaTemplate/dependent-template-recover.cpp    |  60 ++++
 .../test/SemaTemplate/dependent-type-identity.cpp  | 100 ++++++
 clang/test/SemaTemplate/destructor-template.cpp    |  59 ++++
 .../SemaTemplate/elaborated-type-specifier.cpp     |  40 +++
 clang/test/SemaTemplate/enum-argument.cpp          |  36 ++
 clang/test/SemaTemplate/enum-forward.cpp           |   8 +
 clang/test/SemaTemplate/example-dynarray.cpp       | 177 ++++++++++
 clang/test/SemaTemplate/example-typelist.cpp       |  98 ++++++
 clang/test/SemaTemplate/explicit-instantiation.cpp | 107 ++++++
 .../explicit-specialization-member.cpp             |  21 ++
 clang/test/SemaTemplate/ext-vector-type.cpp        |  94 ++++++
 clang/test/SemaTemplate/extern-templates.cpp       |  64 ++++
 clang/test/SemaTemplate/fibonacci.cpp              |  66 ++++
 clang/test/SemaTemplate/friend-template.cpp        | 245 ++++++++++++++
 clang/test/SemaTemplate/friend.cpp                 |  33 ++
 clang/test/SemaTemplate/fun-template-def.cpp       |  48 +++
 .../function-template-specialization.cpp           |  48 +++
 .../test/SemaTemplate/implicit-instantiation-1.cpp |  25 ++
 .../SemaTemplate/inject-templated-friend-post.cpp  |  72 ++++
 .../test/SemaTemplate/inject-templated-friend.cpp  |  48 +++
 clang/test/SemaTemplate/injected-class-name.cpp    |  62 ++++
 .../SemaTemplate/instantiate-anonymous-union.cpp   |  89 +++++
 clang/test/SemaTemplate/instantiate-array.cpp      |  28 ++
 clang/test/SemaTemplate/instantiate-attr.cpp       |  26 ++
 clang/test/SemaTemplate/instantiate-c99.cpp        |  81 +++++
 clang/test/SemaTemplate/instantiate-call.cpp       |  51 +++
 clang/test/SemaTemplate/instantiate-case.cpp       |  21 ++
 clang/test/SemaTemplate/instantiate-cast.cpp       | 117 +++++++
 clang/test/SemaTemplate/instantiate-clang.cpp      |  35 ++
 clang/test/SemaTemplate/instantiate-complete.cpp   | 146 +++++++++
 clang/test/SemaTemplate/instantiate-decl-dtor.cpp  |  11 +
 clang/test/SemaTemplate/instantiate-decl-init.cpp  |  46 +++
 .../test/SemaTemplate/instantiate-declref-ice.cpp  |  34 ++
 clang/test/SemaTemplate/instantiate-declref.cpp    | 117 +++++++
 clang/test/SemaTemplate/instantiate-deeply.cpp     |  36 ++
 .../instantiate-default-assignment-operator.cpp    |  17 +
 .../instantiate-dependent-nested-name.cpp          |   7 +
 .../instantiate-elab-type-specifier.cpp            |  13 +
 clang/test/SemaTemplate/instantiate-enum-2.cpp     |   9 +
 clang/test/SemaTemplate/instantiate-enum.cpp       |  27 ++
 .../instantiate-exception-spec-cxx11.cpp           | 133 ++++++++
 .../SemaTemplate/instantiate-exception-spec.cpp    |  11 +
 clang/test/SemaTemplate/instantiate-expr-1.cpp     | 192 +++++++++++
 clang/test/SemaTemplate/instantiate-expr-2.cpp     | 245 ++++++++++++++
 clang/test/SemaTemplate/instantiate-expr-3.cpp     | 119 +++++++
 clang/test/SemaTemplate/instantiate-expr-4.cpp     | 354 ++++++++++++++++++++
 clang/test/SemaTemplate/instantiate-expr-5.cpp     |  38 +++
 clang/test/SemaTemplate/instantiate-expr-basic.cpp |  17 +
 clang/test/SemaTemplate/instantiate-field.cpp      | 104 ++++++
 .../test/SemaTemplate/instantiate-friend-class.cpp |   9 +
 clang/test/SemaTemplate/instantiate-function-1.cpp | 249 ++++++++++++++
 clang/test/SemaTemplate/instantiate-function-1.mm  |  17 +
 clang/test/SemaTemplate/instantiate-function-2.cpp |  66 ++++
 .../SemaTemplate/instantiate-function-params.cpp   |  90 +++++
 clang/test/SemaTemplate/instantiate-init.cpp       | 109 +++++++
 clang/test/SemaTemplate/instantiate-invalid.cpp    |  52 +++
 .../test/SemaTemplate/instantiate-local-class.cpp  |  67 ++++
 .../test/SemaTemplate/instantiate-member-class.cpp | 142 ++++++++
 .../test/SemaTemplate/instantiate-member-expr.cpp  |  68 ++++
 .../instantiate-member-initializers.cpp            |  27 ++
 .../SemaTemplate/instantiate-member-pointers.cpp   |  67 ++++
 .../SemaTemplate/instantiate-member-template.cpp   | 261 +++++++++++++++
 clang/test/SemaTemplate/instantiate-method.cpp     | 177 ++++++++++
 .../instantiate-non-dependent-types.cpp            |  14 +
 .../instantiate-non-type-template-parameter.cpp    |  55 ++++
 clang/test/SemaTemplate/instantiate-objc-1.mm      |  48 +++
 .../instantiate-overload-candidates.cpp            |  21 ++
 .../SemaTemplate/instantiate-overloaded-arrow.cpp  |  20 ++
 clang/test/SemaTemplate/instantiate-self.cpp       |  89 +++++
 clang/test/SemaTemplate/instantiate-sizeof.cpp     |  10 +
 clang/test/SemaTemplate/instantiate-static-var.cpp | 116 +++++++
 clang/test/SemaTemplate/instantiate-subscript.cpp  |  41 +++
 .../instantiate-template-template-parm.cpp         |  97 ++++++
 clang/test/SemaTemplate/instantiate-try-catch.cpp  |  31 ++
 clang/test/SemaTemplate/instantiate-type.cpp       |  17 +
 clang/test/SemaTemplate/instantiate-typedef.cpp    |  15 +
 clang/test/SemaTemplate/instantiate-typeof.cpp     |  10 +
 clang/test/SemaTemplate/instantiate-using-decl.cpp |  82 +++++
 .../test/SemaTemplate/instantiation-backtrace.cpp  |  32 ++
 .../test/SemaTemplate/instantiation-default-1.cpp  | 102 ++++++
 .../test/SemaTemplate/instantiation-default-2.cpp  |  18 +
 .../test/SemaTemplate/instantiation-default-3.cpp  |  21 ++
 clang/test/SemaTemplate/instantiation-depth.cpp    |  13 +
 clang/test/SemaTemplate/instantiation-order.cpp    |  15 +
 clang/test/SemaTemplate/issue150.cpp               | 107 ++++++
 clang/test/SemaTemplate/lookup-dependent-bases.cpp |  19 ++
 clang/test/SemaTemplate/member-access-ambig.cpp    |  45 +++
 clang/test/SemaTemplate/member-access-expr.cpp     | 149 +++++++++
 .../test/SemaTemplate/member-function-template.cpp | 103 ++++++
 .../member-inclass-init-value-dependent.cpp        |  18 +
 clang/test/SemaTemplate/member-initializers.cpp    |  13 +
 .../SemaTemplate/member-template-access-expr.cpp   | 144 ++++++++
 clang/test/SemaTemplate/metafun-apply.cpp          |  40 +++
 .../SemaTemplate/missing-class-keyword-crash.cpp   |   7 +
 .../ms-function-specialization-class-scope.cpp     |  71 ++++
 clang/test/SemaTemplate/ms-if-exists.cpp           |  68 ++++
 .../ms-lookup-template-base-classes.cpp            | 145 ++++++++
 .../test/SemaTemplate/nested-incomplete-class.cpp  |  21 ++
 clang/test/SemaTemplate/nested-linkage.cpp         |   3 +
 .../SemaTemplate/nested-name-spec-template.cpp     | 142 ++++++++
 clang/test/SemaTemplate/nested-template.cpp        | 157 +++++++++
 .../SemaTemplate/operator-function-id-template.cpp |  28 ++
 clang/test/SemaTemplate/operator-template.cpp      |  18 +
 clang/test/SemaTemplate/overload-candidates.cpp    |  40 +++
 clang/test/SemaTemplate/overload-uneval.cpp        |  42 +++
 .../test/SemaTemplate/partial-spec-instantiate.cpp |  50 +++
 clang/test/SemaTemplate/pragma-ms_struct.cpp       |  10 +
 clang/test/SemaTemplate/qualified-id.cpp           |  56 ++++
 clang/test/SemaTemplate/qualified-names-diag.cpp   |  16 +
 clang/test/SemaTemplate/rdar9173693.cpp            |   6 +
 clang/test/SemaTemplate/recovery-crash.cpp         |  19 ++
 .../recursive-template-instantiation.cpp           |  10 +
 .../SemaTemplate/resolve-single-template-id.cpp    |  82 +++++
 clang/test/SemaTemplate/self-comparison.cpp        |  48 +++
 clang/test/SemaTemplate/temp.cpp                   |  19 ++
 clang/test/SemaTemplate/temp_arg.cpp               |  20 ++
 clang/test/SemaTemplate/temp_arg_nontype.cpp       | 325 ++++++++++++++++++
 clang/test/SemaTemplate/temp_arg_template.cpp      |  62 ++++
 clang/test/SemaTemplate/temp_arg_type.cpp          |  42 +++
 clang/test/SemaTemplate/temp_class_order.cpp       |  42 +++
 clang/test/SemaTemplate/temp_class_spec.cpp        | 363 +++++++++++++++++++++
 clang/test/SemaTemplate/temp_class_spec_blocks.cpp |  34 ++
 clang/test/SemaTemplate/temp_class_spec_neg.cpp    |  45 +++
 clang/test/SemaTemplate/temp_explicit.cpp          | 151 +++++++++
 clang/test/SemaTemplate/temp_explicit_cxx0x.cpp    |  24 ++
 clang/test/SemaTemplate/temp_func_order.cpp        |  95 ++++++
 clang/test/SemaTemplate/template-class-traits.cpp  |   8 +
 clang/test/SemaTemplate/template-decl-fail.cpp     |  10 +
 clang/test/SemaTemplate/template-id-expr.cpp       |  98 ++++++
 clang/test/SemaTemplate/template-id-printing.cpp   | 141 ++++++++
 clang/test/SemaTemplate/typename-specifier-2.cpp   |  30 ++
 clang/test/SemaTemplate/typename-specifier-3.cpp   |  19 ++
 clang/test/SemaTemplate/typename-specifier-4.cpp   | 164 ++++++++++
 clang/test/SemaTemplate/typename-specifier.cpp     | 117 +++++++
 clang/test/SemaTemplate/typo-dependent-name.cpp    |  17 +
 clang/test/SemaTemplate/unresolved-construct.cpp   |  19 ++
 clang/test/SemaTemplate/unused-variables.cpp       |  21 ++
 .../value-dependent-null-pointer-constant.cpp      |  29 ++
 .../test/SemaTemplate/virtual-member-functions.cpp |  86 +++++
 177 files changed, 12320 insertions(+)
 create mode 100644 clang/test/SemaTemplate/ackermann.cpp
 create mode 100644 clang/test/SemaTemplate/address-spaces.cpp
 create mode 100644 clang/test/SemaTemplate/alias-church-numerals.cpp
 create mode 100644 clang/test/SemaTemplate/alias-nested-nontag.cpp
 create mode 100644 clang/test/SemaTemplate/alias-template-template-param.cpp
 create mode 100644 clang/test/SemaTemplate/alias-templates.cpp
 create mode 100644 clang/test/SemaTemplate/ambiguous-ovl-print.cpp
 create mode 100644 clang/test/SemaTemplate/anonymous-union.cpp
 create mode 100644 clang/test/SemaTemplate/array-to-pointer-decay.cpp
 create mode 100644 clang/test/SemaTemplate/atomics.cpp
 create mode 100644 clang/test/SemaTemplate/attributes.cpp
 create mode 100644 clang/test/SemaTemplate/canonical-expr-type-0x.cpp
 create mode 100644 clang/test/SemaTemplate/canonical-expr-type.cpp
 create mode 100644 clang/test/SemaTemplate/class-template-ctor-initializer.cpp
 create mode 100644 clang/test/SemaTemplate/class-template-decl.cpp
 create mode 100644 clang/test/SemaTemplate/class-template-id-2.cpp
 create mode 100644 clang/test/SemaTemplate/class-template-id.cpp
 create mode 100644 clang/test/SemaTemplate/class-template-spec.cpp
 create mode 100644 clang/test/SemaTemplate/constexpr-instantiate.cpp
 create mode 100644 clang/test/SemaTemplate/constructor-template.cpp
 create mode 100644 clang/test/SemaTemplate/copy-ctor-assign.cpp
 create mode 100644 clang/test/SemaTemplate/crash-10438657.cpp
 create mode 100644 clang/test/SemaTemplate/crash-8204126.cpp
 create mode 100644 clang/test/SemaTemplate/current-instantiation.cpp
 create mode 100644 clang/test/SemaTemplate/deduction-crash.cpp
 create mode 100644 clang/test/SemaTemplate/deduction.cpp
 create mode 100644 clang/test/SemaTemplate/default-arguments-cxx0x.cpp
 create mode 100644 clang/test/SemaTemplate/default-arguments.cpp
 create mode 100644 clang/test/SemaTemplate/default-expr-arguments-2.cpp
 create mode 100644 clang/test/SemaTemplate/default-expr-arguments.cpp
 create mode 100644 clang/test/SemaTemplate/delegating-constructors.cpp
 create mode 100644 clang/test/SemaTemplate/dependent-base-classes.cpp
 create mode 100644 clang/test/SemaTemplate/dependent-base-member-init.cpp
 create mode 100644 clang/test/SemaTemplate/dependent-class-member-operator.cpp
 create mode 100644 clang/test/SemaTemplate/dependent-expr.cpp
 create mode 100644 clang/test/SemaTemplate/dependent-names-no-std.cpp
 create mode 100644 clang/test/SemaTemplate/dependent-names.cpp
 create mode 100644 clang/test/SemaTemplate/dependent-sized_array.cpp
 create mode 100644 clang/test/SemaTemplate/dependent-template-recover.cpp
 create mode 100644 clang/test/SemaTemplate/dependent-type-identity.cpp
 create mode 100644 clang/test/SemaTemplate/destructor-template.cpp
 create mode 100644 clang/test/SemaTemplate/elaborated-type-specifier.cpp
 create mode 100644 clang/test/SemaTemplate/enum-argument.cpp
 create mode 100644 clang/test/SemaTemplate/enum-forward.cpp
 create mode 100644 clang/test/SemaTemplate/example-dynarray.cpp
 create mode 100644 clang/test/SemaTemplate/example-typelist.cpp
 create mode 100644 clang/test/SemaTemplate/explicit-instantiation.cpp
 create mode 100644 clang/test/SemaTemplate/explicit-specialization-member.cpp
 create mode 100644 clang/test/SemaTemplate/ext-vector-type.cpp
 create mode 100644 clang/test/SemaTemplate/extern-templates.cpp
 create mode 100644 clang/test/SemaTemplate/fibonacci.cpp
 create mode 100644 clang/test/SemaTemplate/friend-template.cpp
 create mode 100644 clang/test/SemaTemplate/friend.cpp
 create mode 100644 clang/test/SemaTemplate/fun-template-def.cpp
 create mode 100644 clang/test/SemaTemplate/function-template-specialization.cpp
 create mode 100644 clang/test/SemaTemplate/implicit-instantiation-1.cpp
 create mode 100644 clang/test/SemaTemplate/inject-templated-friend-post.cpp
 create mode 100644 clang/test/SemaTemplate/inject-templated-friend.cpp
 create mode 100644 clang/test/SemaTemplate/injected-class-name.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-anonymous-union.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-array.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-attr.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-c99.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-call.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-case.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-cast.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-clang.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-complete.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-decl-dtor.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-decl-init.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-declref-ice.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-declref.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-deeply.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-default-assignment-operator.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-dependent-nested-name.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-elab-type-specifier.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-enum-2.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-enum.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-exception-spec-cxx11.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-exception-spec.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-expr-1.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-expr-2.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-expr-3.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-expr-4.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-expr-5.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-expr-basic.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-field.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-friend-class.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-function-1.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-function-1.mm
 create mode 100644 clang/test/SemaTemplate/instantiate-function-2.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-function-params.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-init.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-invalid.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-local-class.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-member-class.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-member-expr.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-member-initializers.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-member-pointers.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-member-template.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-method.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-non-dependent-types.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-non-type-template-parameter.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-objc-1.mm
 create mode 100644 clang/test/SemaTemplate/instantiate-overload-candidates.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-overloaded-arrow.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-self.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-sizeof.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-static-var.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-subscript.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-template-template-parm.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-try-catch.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-type.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-typedef.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-typeof.cpp
 create mode 100644 clang/test/SemaTemplate/instantiate-using-decl.cpp
 create mode 100644 clang/test/SemaTemplate/instantiation-backtrace.cpp
 create mode 100644 clang/test/SemaTemplate/instantiation-default-1.cpp
 create mode 100644 clang/test/SemaTemplate/instantiation-default-2.cpp
 create mode 100644 clang/test/SemaTemplate/instantiation-default-3.cpp
 create mode 100644 clang/test/SemaTemplate/instantiation-depth.cpp
 create mode 100644 clang/test/SemaTemplate/instantiation-order.cpp
 create mode 100644 clang/test/SemaTemplate/issue150.cpp
 create mode 100644 clang/test/SemaTemplate/lookup-dependent-bases.cpp
 create mode 100644 clang/test/SemaTemplate/member-access-ambig.cpp
 create mode 100644 clang/test/SemaTemplate/member-access-expr.cpp
 create mode 100644 clang/test/SemaTemplate/member-function-template.cpp
 create mode 100644 clang/test/SemaTemplate/member-inclass-init-value-dependent.cpp
 create mode 100644 clang/test/SemaTemplate/member-initializers.cpp
 create mode 100644 clang/test/SemaTemplate/member-template-access-expr.cpp
 create mode 100644 clang/test/SemaTemplate/metafun-apply.cpp
 create mode 100644 clang/test/SemaTemplate/missing-class-keyword-crash.cpp
 create mode 100644 clang/test/SemaTemplate/ms-function-specialization-class-scope.cpp
 create mode 100644 clang/test/SemaTemplate/ms-if-exists.cpp
 create mode 100644 clang/test/SemaTemplate/ms-lookup-template-base-classes.cpp
 create mode 100644 clang/test/SemaTemplate/nested-incomplete-class.cpp
 create mode 100644 clang/test/SemaTemplate/nested-linkage.cpp
 create mode 100644 clang/test/SemaTemplate/nested-name-spec-template.cpp
 create mode 100644 clang/test/SemaTemplate/nested-template.cpp
 create mode 100644 clang/test/SemaTemplate/operator-function-id-template.cpp
 create mode 100644 clang/test/SemaTemplate/operator-template.cpp
 create mode 100644 clang/test/SemaTemplate/overload-candidates.cpp
 create mode 100644 clang/test/SemaTemplate/overload-uneval.cpp
 create mode 100644 clang/test/SemaTemplate/partial-spec-instantiate.cpp
 create mode 100644 clang/test/SemaTemplate/pragma-ms_struct.cpp
 create mode 100644 clang/test/SemaTemplate/qualified-id.cpp
 create mode 100644 clang/test/SemaTemplate/qualified-names-diag.cpp
 create mode 100644 clang/test/SemaTemplate/rdar9173693.cpp
 create mode 100644 clang/test/SemaTemplate/recovery-crash.cpp
 create mode 100644 clang/test/SemaTemplate/recursive-template-instantiation.cpp
 create mode 100644 clang/test/SemaTemplate/resolve-single-template-id.cpp
 create mode 100644 clang/test/SemaTemplate/self-comparison.cpp
 create mode 100644 clang/test/SemaTemplate/temp.cpp
 create mode 100644 clang/test/SemaTemplate/temp_arg.cpp
 create mode 100644 clang/test/SemaTemplate/temp_arg_nontype.cpp
 create mode 100644 clang/test/SemaTemplate/temp_arg_template.cpp
 create mode 100644 clang/test/SemaTemplate/temp_arg_type.cpp
 create mode 100644 clang/test/SemaTemplate/temp_class_order.cpp
 create mode 100644 clang/test/SemaTemplate/temp_class_spec.cpp
 create mode 100644 clang/test/SemaTemplate/temp_class_spec_blocks.cpp
 create mode 100644 clang/test/SemaTemplate/temp_class_spec_neg.cpp
 create mode 100644 clang/test/SemaTemplate/temp_explicit.cpp
 create mode 100644 clang/test/SemaTemplate/temp_explicit_cxx0x.cpp
 create mode 100644 clang/test/SemaTemplate/temp_func_order.cpp
 create mode 100644 clang/test/SemaTemplate/template-class-traits.cpp
 create mode 100644 clang/test/SemaTemplate/template-decl-fail.cpp
 create mode 100644 clang/test/SemaTemplate/template-id-expr.cpp
 create mode 100644 clang/test/SemaTemplate/template-id-printing.cpp
 create mode 100644 clang/test/SemaTemplate/typename-specifier-2.cpp
 create mode 100644 clang/test/SemaTemplate/typename-specifier-3.cpp
 create mode 100644 clang/test/SemaTemplate/typename-specifier-4.cpp
 create mode 100644 clang/test/SemaTemplate/typename-specifier.cpp
 create mode 100644 clang/test/SemaTemplate/typo-dependent-name.cpp
 create mode 100644 clang/test/SemaTemplate/unresolved-construct.cpp
 create mode 100644 clang/test/SemaTemplate/unused-variables.cpp
 create mode 100644 clang/test/SemaTemplate/value-dependent-null-pointer-constant.cpp
 create mode 100644 clang/test/SemaTemplate/virtual-member-functions.cpp

(limited to 'clang/test/SemaTemplate')

diff --git a/clang/test/SemaTemplate/ackermann.cpp b/clang/test/SemaTemplate/ackermann.cpp
new file mode 100644
index 0000000..9525bfc
--- /dev/null
+++ b/clang/test/SemaTemplate/ackermann.cpp
@@ -0,0 +1,38 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// template<unsigned M, unsigned N>
+// struct Ackermann {
+//   enum {
+//     value = M ? (N ? Ackermann<M-1, Ackermann<M, N-1> >::value
+//                    : Ackermann<M-1, 1>::value)
+//               : N + 1
+//   };
+// };
+
+template<unsigned M, unsigned N>
+struct Ackermann {
+ enum {
+   value = Ackermann<M-1, Ackermann<M, N-1>::value >::value
+ };
+};
+
+template<unsigned M> struct Ackermann<M, 0> {
+ enum {
+   value = Ackermann<M-1, 1>::value
+ };
+};
+
+template<unsigned N> struct Ackermann<0, N> {
+ enum {
+   value = N + 1
+ };
+};
+
+template<> struct Ackermann<0, 0> {
+ enum {
+   value = 1
+ };
+};
+
+int g0[Ackermann<3, 4>::value == 125 ? 1 : -1];
+
diff --git a/clang/test/SemaTemplate/address-spaces.cpp b/clang/test/SemaTemplate/address-spaces.cpp
new file mode 100644
index 0000000..eda03db
--- /dev/null
+++ b/clang/test/SemaTemplate/address-spaces.cpp
@@ -0,0 +1,86 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+typedef int __attribute__((address_space(1))) int_1;;
+typedef int __attribute__((address_space(2))) int_2;;
+typedef int __attribute__((address_space(1))) *int_1_ptr;
+typedef int_2 *int_2_ptr;
+
+// Check that we maintain address spaces through template argument
+// deduction from a type.
+template<typename T>
+struct remove_pointer {
+  typedef T type;
+};
+
+template<typename T>
+struct remove_pointer<T *> {
+  typedef T type;
+};
+
+int check_remove0[is_same<remove_pointer<int_1_ptr>::type, int_1>::value? 1 : -1];
+int check_remove1[is_same<remove_pointer<int_2_ptr>::type, int_2>::value? 1 : -1];
+int check_remove2[is_same<remove_pointer<int_2_ptr>::type, int>::value? -1 : 1];
+int check_remove3[is_same<remove_pointer<int_2_ptr>::type, int_1>::value? -1 : 1];
+
+template<typename T>
+struct is_pointer_in_address_space_1 {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_pointer_in_address_space_1<T __attribute__((address_space(1))) *> {
+  static const bool value = true;
+};
+                
+int check_ptr_in_as1[is_pointer_in_address_space_1<int_1_ptr>::value? 1 : -1];
+int check_ptr_in_as2[is_pointer_in_address_space_1<int_2_ptr>::value? -1 : 1];
+int check_ptr_in_as3[is_pointer_in_address_space_1<int*>::value? -1 : 1];
+
+// Check that we maintain address spaces through template argument
+// deduction for a call.
+template<typename T>
+void accept_any_pointer(T*) {
+  T *x = 1; // expected-error{{cannot initialize a variable of type '__attribute__((address_space(1))) int *' with an rvalue of type 'int'}} \
+  // expected-error{{cannot initialize a variable of type '__attribute__((address_space(3))) int *' with an rvalue of type 'int'}}
+}
+
+void test_accept_any_pointer(int_1_ptr ip1, int_2_ptr ip2) {
+  static __attribute__((address_space(3))) int array[17];
+  accept_any_pointer(ip1); // expected-note{{in instantiation of}}
+  accept_any_pointer(array); // expected-note{{in instantiation of}}
+}
+
+template<typename T> struct identity {};
+
+template<typename T>
+identity<T> accept_arg_in_address_space_1(__attribute__((address_space(1))) T &ir1);
+
+template<typename T>
+identity<T> accept_any_arg(T &ir1);
+
+void test_arg_in_address_space_1() {
+  static int __attribute__((address_space(1))) int_1;
+  identity<int> ii = accept_arg_in_address_space_1(int_1);
+  identity<int __attribute__((address_space(1)))> ii2 = accept_any_arg(int_1);
+}
+
+// Partial ordering
+template<typename T> int &order1(__attribute__((address_space(1))) T&);
+template<typename T> float &order1(T&);
+
+void test_order1() {
+  static __attribute__((address_space(1))) int i1;
+  int i;
+  int &ir = order1(i1);
+  float &fr = order1(i);
+}
diff --git a/clang/test/SemaTemplate/alias-church-numerals.cpp b/clang/test/SemaTemplate/alias-church-numerals.cpp
new file mode 100644
index 0000000..69d7716
--- /dev/null
+++ b/clang/test/SemaTemplate/alias-church-numerals.cpp
@@ -0,0 +1,34 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+template<template<template<typename> class, typename> class T, template<typename> class V> struct PartialApply {
+  template<typename W> using R = T<V, W>;
+};
+
+template<typename T> using Id = T;
+template<template<typename> class, typename X> using Zero = X;
+template<template<template<typename> class, typename> class N, template<typename> class F, typename X> using Succ = F<N<F,X>>;
+
+template<template<typename> class F, typename X> using One = Succ<Zero, F, X>;
+template<template<typename> class F, typename X> using Two = Succ<One, F, X>;
+
+template<template<template<typename> class, typename> class A,
+         template<template<typename> class, typename> class B,
+         template<typename> class F,
+         typename X> using Add = A<F, B<F, X>>;
+
+template<template<template<typename> class, typename> class A,
+         template<template<typename> class, typename> class B,
+         template<typename> class F,
+         typename X> using Mul = A<PartialApply<B,F>::template R, X>;
+
+template<template<typename> class F, typename X> using Four = Add<Two, Two, F, X>;
+template<template<typename> class F, typename X> using Sixteen = Mul<Four, Four, F, X>;
+template<template<typename> class F, typename X> using TwoHundredAndFiftySix = Mul<Sixteen, Sixteen, F, X>;
+
+template<typename T, T N> struct Const { static const T value = N; };
+template<typename A> struct IncrementHelper;
+template<typename T, T N> struct IncrementHelper<Const<T, N>> { using Result = Const<T, N+1>; };
+template<typename A> using Increment = typename IncrementHelper<A>::Result;
+
+using Arr = int[TwoHundredAndFiftySix<Increment, Const<int, 0>>::value];
+using Arr = int[256];
diff --git a/clang/test/SemaTemplate/alias-nested-nontag.cpp b/clang/test/SemaTemplate/alias-nested-nontag.cpp
new file mode 100644
index 0000000..4b5226b
--- /dev/null
+++ b/clang/test/SemaTemplate/alias-nested-nontag.cpp
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
+template<typename T> using Id = T; // expected-note {{type alias template 'Id' declared here}}
+struct U { static Id<int> V; };
+Id<int> ::U::V; // expected-error {{type 'Id<int>' (aka 'int') cannot be used prior to '::' because it has no members}} \
+                   expected-error {{C++ requires a type specifier}}
diff --git a/clang/test/SemaTemplate/alias-template-template-param.cpp b/clang/test/SemaTemplate/alias-template-template-param.cpp
new file mode 100644
index 0000000..c22fccb
--- /dev/null
+++ b/clang/test/SemaTemplate/alias-template-template-param.cpp
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
+template<template<typename> class D> using C = D<int>;
+
+// Substitution of the alias template transforms the TemplateSpecializationType
+// 'D<int>' into the DependentTemplateSpecializationType 'T::template U<int>'.
+template<typename T> void f(C<T::template U>);
diff --git a/clang/test/SemaTemplate/alias-templates.cpp b/clang/test/SemaTemplate/alias-templates.cpp
new file mode 100644
index 0000000..75615ee
--- /dev/null
+++ b/clang/test/SemaTemplate/alias-templates.cpp
@@ -0,0 +1,102 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+template<typename S>
+struct A {
+  typedef S B;
+  template<typename T> using C = typename T::B;
+  template<typename T> struct D {
+    template<typename U> using E = typename A<U>::template C<A<T>>;
+    template<typename U> using F = A<E<U>>;
+    template<typename U> using G = C<F<U>>;
+    G<T> g;
+  };
+  typedef decltype(D<B>().g) H;
+  D<H> h;
+  template<typename T> using I = A<decltype(h.g)>;
+  template<typename T> using J = typename A<decltype(h.g)>::template C<I<T>>;
+};
+
+A<int> a;
+A<char>::D<double> b;
+
+template<typename T> T make();
+
+namespace X {
+  template<typename T> struct traits {
+    typedef T thing;
+    typedef decltype(val(make<thing>())) inner_ptr;
+
+    template<typename U> using rebind_thing = typename thing::template rebind<U>;
+    template<typename U> using rebind = traits<rebind_thing<U>>;
+
+    inner_ptr &&alloc();
+    void free(inner_ptr&&);
+  };
+
+  template<typename T> struct ptr_traits {
+    typedef T *type;
+  };
+  template<typename T> using ptr = typename ptr_traits<T>::type;
+
+  template<typename T> struct thing {
+    typedef T inner;
+    typedef ptr<inner> inner_ptr;
+    typedef traits<thing<inner>> traits_type;
+
+    template<typename U> using rebind = thing<U>;
+
+    thing(traits_type &traits) : traits(traits), val(traits.alloc()) {}
+    ~thing() { traits.free(static_cast<inner_ptr&&>(val)); }
+
+    traits_type &traits;
+    inner_ptr val;
+
+    friend inner_ptr val(const thing &t) { return t.val; }
+  };
+
+  template<> struct ptr_traits<bool> {
+    typedef bool &type;
+  };
+  template<> bool &traits<thing<bool>>::alloc() { static bool b; return b; }
+  template<> void traits<thing<bool>>::free(bool&) {}
+}
+
+typedef X::traits<X::thing<int>> itt;
+
+itt::thing::traits_type itr;
+itt::thing ith(itr);
+
+itt::rebind<bool> btr;
+itt::rebind_thing<bool> btt(btr);
+
+namespace PR11848 {
+  template<typename T> using U = int;
+
+  template<typename T, typename ...Ts>
+  void f(U<T> i, U<Ts> ...is) { // expected-error {{type 'U<Ts>' (aka 'int') of function parameter pack does not contain any unexpanded parameter packs}}
+    return i + f<Ts...>(is...); // expected-error {{pack expansion does not contain any unexpanded parameter packs}}
+  }
+
+  template<typename ...Ts>
+  struct S {
+    S(U<Ts>...ts); // expected-error {{does not contain any unexpanded parameter packs}}
+  };
+
+  template<typename T>
+  struct Hidden1 {
+    template<typename ...Ts>
+    Hidden1(typename T::template U<Ts> ...ts); // expected-error{{type 'typename Hide::U<Ts>' (aka 'int') of function parameter pack does not contain any unexpanded parameter packs}}
+  };
+
+  template<typename T, typename ...Ts>
+  struct Hidden2 {
+    Hidden2(typename T::template U<Ts> ...ts);
+  };
+
+  struct Hide {
+    template<typename T> using U = int;
+  };
+
+  Hidden1<Hide> h1;  // expected-note{{in instantiation of template class 'PR11848::Hidden1<PR11848::Hide>' requested here}}
+  Hidden2<Hide, double, char> h2(1, 2);
+}
diff --git a/clang/test/SemaTemplate/ambiguous-ovl-print.cpp b/clang/test/SemaTemplate/ambiguous-ovl-print.cpp
new file mode 100644
index 0000000..7e3fa24
--- /dev/null
+++ b/clang/test/SemaTemplate/ambiguous-ovl-print.cpp
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+void f(void*, int); // expected-note{{candidate function}}
+template<typename T>
+  void f(T*, long); // expected-note{{candidate function}}
+
+void test_f(int *ip, int i) {
+  f(ip, i); // expected-error{{ambiguous}}
+}
diff --git a/clang/test/SemaTemplate/anonymous-union.cpp b/clang/test/SemaTemplate/anonymous-union.cpp
new file mode 100644
index 0000000..97ecd6e
--- /dev/null
+++ b/clang/test/SemaTemplate/anonymous-union.cpp
@@ -0,0 +1,40 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// PR5868
+struct T0 {
+  int x;
+  union {
+    void *m0;
+  };
+};
+template <typename T>
+struct T1 : public T0, public T { 
+  void f0() { 
+    m0 = 0; // expected-error{{ambiguous conversion}}
+  } 
+};
+
+struct A : public T0 { };
+
+void f1(T1<A> *S) { S->f0(); } // expected-note{{instantiation of member function}}
+
+namespace rdar8635664 {
+  template<typename T>
+  struct X {
+    struct inner;
+  
+    struct inner {
+      union {
+        int x;
+        float y;
+      };
+
+      typedef T type;
+    };
+  };
+
+  void test() {
+    X<int>::inner i;
+    i.x = 0;
+  }
+}
diff --git a/clang/test/SemaTemplate/array-to-pointer-decay.cpp b/clang/test/SemaTemplate/array-to-pointer-decay.cpp
new file mode 100644
index 0000000..072c0e5
--- /dev/null
+++ b/clang/test/SemaTemplate/array-to-pointer-decay.cpp
@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+struct mystruct {
+  int  member;
+};
+
+template <int i>
+int foo() {
+  mystruct s[1];
+  return s->member;
+}
+
+int main() {
+  foo<1>();
+}
+
+// PR7405
+struct hb_sanitize_context_t {
+  int start;
+};
+template <typename Type> static bool sanitize() {
+  hb_sanitize_context_t c[1];
+  return !c->start;
+}
+bool closure = sanitize<int>();
diff --git a/clang/test/SemaTemplate/atomics.cpp b/clang/test/SemaTemplate/atomics.cpp
new file mode 100644
index 0000000..e9fdc9d
--- /dev/null
+++ b/clang/test/SemaTemplate/atomics.cpp
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// PR8345
+template<typename T> T f(T* value) {
+  return __sync_add_and_fetch(value, 1);
+}
+int g(long long* x) { return f(x); }
+int g(int* x) { return f(x); }
+
+namespace PR11320 {
+  template<typename T> 
+  void g(unsigned *x) { 
+    __sync_bool_compare_and_swap(x, 1, 4); 
+  }
+  void h() { g<int>(0); }
+}
diff --git a/clang/test/SemaTemplate/attributes.cpp b/clang/test/SemaTemplate/attributes.cpp
new file mode 100644
index 0000000..495f4a7
--- /dev/null
+++ b/clang/test/SemaTemplate/attributes.cpp
@@ -0,0 +1,34 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+namespace attribute_aligned {
+  template<int N>
+  struct X {
+    char c[1] __attribute__((__aligned__((N)))); // expected-error {{alignment is not a power of 2}}
+  };
+
+  template <bool X> struct check {
+    int check_failed[X ? 1 : -1]; // expected-error {{array with a negative size}}
+  };
+
+  template <int N> struct check_alignment {
+    typedef check<N == sizeof(X<N>)> t; // expected-note {{in instantiation}}
+  };
+
+  check_alignment<1>::t c1;
+  check_alignment<2>::t c2;
+  check_alignment<3>::t c3; // expected-note 2 {{in instantiation}}
+  check_alignment<4>::t c4;
+}
+
+namespace PR9049 {
+  extern const void *CFRetain(const void *ref);
+
+  template<typename T> __attribute__((cf_returns_retained))
+  inline T WBCFRetain(T aValue) { return aValue ? (T)CFRetain(aValue) : (T)0; }
+
+
+  extern void CFRelease(const void *ref);
+
+  template<typename T>
+  inline void WBCFRelease(__attribute__((cf_consumed)) T aValue) { if(aValue) CFRelease(aValue); }
+}
diff --git a/clang/test/SemaTemplate/canonical-expr-type-0x.cpp b/clang/test/SemaTemplate/canonical-expr-type-0x.cpp
new file mode 100644
index 0000000..d7379ea
--- /dev/null
+++ b/clang/test/SemaTemplate/canonical-expr-type-0x.cpp
@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
+void f();
+
+// Test typeof(expr) canonicalization
+template<typename T, T N>
+void f0(T x, decltype(f(N, x)) y) { } // expected-note{{previous}}
+
+template<typename T, T N>
+void f0(T x, decltype((f)(N, x)) y) { }
+
+template<typename U, U M>
+void f0(U u, decltype(f(M, u))) { } // expected-error{{redefinition}}
+
+// PR12438: Test sizeof...() canonicalization
+template<int> struct N {};
+
+template<typename...T>
+N<sizeof...(T)> f1() {} // expected-note{{previous}}
+
+template<typename, typename...T>
+N<sizeof...(T)> f1() {}
+
+template<class...U>
+N<sizeof...(U)> f1() {} // expected-error{{redefinition}}
diff --git a/clang/test/SemaTemplate/canonical-expr-type.cpp b/clang/test/SemaTemplate/canonical-expr-type.cpp
new file mode 100644
index 0000000..7582df5
--- /dev/null
+++ b/clang/test/SemaTemplate/canonical-expr-type.cpp
@@ -0,0 +1,53 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+void f();
+
+// Test typeof(expr) canonicalization
+template<typename T>
+void f0(T x, __typeof__(f(x)) y) { } // expected-note{{previous}}
+
+template<typename T>
+void f0(T x, __typeof__((f)(x)) y) { }
+
+template<typename U>
+void f0(U u, __typeof__(f(u))) { } // expected-error{{redefinition}}
+
+// Test insane typeof(expr) overload set canonicalization
+void f(int);
+void f(double);
+
+template<typename T, T N>
+void f0a(T x, __typeof__(f(N)) y) { } // expected-note{{previous}}
+
+void f(int);
+
+template<typename T, T N>
+void f0a(T x, __typeof__(f(N)) y) { } // expected-error{{redefinition}} \
+                                      // expected-note{{previous}}
+
+void f(float);
+
+template<typename T, T N>
+void f0a(T x, __typeof__(f(N)) y) { } // expected-error{{redefinition}}
+
+// Test dependently-sized array canonicalization
+template<typename T, int N, int M>
+void f1(T (&array)[N + M]) { } // expected-note{{previous}}
+
+template<typename T, int N, int M>
+void f1(T (&array)[M + N]) { }
+
+template<typename T, int M, int N>
+void f1(T (&array)[M + N]) { } // expected-error{{redefinition}}
+
+// Test dependently-sized extended vector type canonicalization
+template<typename T, int N, int M>
+struct X2 {
+  typedef T __attribute__((ext_vector_type(N))) type1;
+  typedef T __attribute__((ext_vector_type(M))) type2;
+  typedef T __attribute__((ext_vector_type(N))) type3;
+  
+  void f0(type1); // expected-note{{previous}}
+  void f0(type2);
+  void f0(type3); // expected-error{{redeclared}}
+};
diff --git a/clang/test/SemaTemplate/class-template-ctor-initializer.cpp b/clang/test/SemaTemplate/class-template-ctor-initializer.cpp
new file mode 100644
index 0000000..44bb4bd
--- /dev/null
+++ b/clang/test/SemaTemplate/class-template-ctor-initializer.cpp
@@ -0,0 +1,55 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<class X> struct A {};
+
+template<class X> struct B : A<X> { 
+  B() : A<X>() {} 
+};
+B<int> x;
+
+template<class X> struct B1 : A<X> {
+  typedef A<X> Base;
+  B1() : Base() {}
+};
+B1<int> x1;
+
+
+template<typename T> struct Tmpl { };
+
+template<typename T> struct TmplB { };
+
+struct TmplC : Tmpl<int> {
+   TmplC() :
+             Tmpl<int>(),
+             TmplB<int>() { } // expected-error {{type 'TmplB<int>' is not a direct or virtual base of 'TmplC'}}
+};
+
+
+struct TmplD : Tmpl<char>, TmplB<char> {
+    TmplD():
+            Tmpl<int>(), // expected-error {{type 'Tmpl<int>' is not a direct or virtual base of 'TmplD'}}
+            TmplB<char>() {}
+};
+
+namespace PR7259 {
+  class Base {
+  public:
+    Base() {}
+  };
+
+  template <class ParentClass>
+  class Derived : public ParentClass {
+  public:
+    Derived() : Base() {}
+  };
+
+  class Final : public Derived<Base> {
+  };
+
+  int
+  main (void)
+  {
+    Final final;
+    return 0;
+  }
+}
diff --git a/clang/test/SemaTemplate/class-template-decl.cpp b/clang/test/SemaTemplate/class-template-decl.cpp
new file mode 100644
index 0000000..ec4e016
--- /dev/null
+++ b/clang/test/SemaTemplate/class-template-decl.cpp
@@ -0,0 +1,97 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T> class A;
+
+extern "C++" {
+  template<typename T> class B;
+}
+
+namespace N {
+  template<typename T> class C;
+}
+
+extern "C" {
+  template<typename T> class D; // expected-error{{templates must have C++ linkage}}
+}
+
+template<class U> class A; // expected-note{{previous template declaration is here}}
+
+template<int N> class A; // expected-error{{template parameter has a different kind in template redeclaration}}
+
+template<int N> class NonTypeTemplateParm;
+
+typedef int INT;
+
+template<INT M> class NonTypeTemplateParm; // expected-note{{previous non-type template parameter with type 'INT' (aka 'int') is here}}
+
+template<long> class NonTypeTemplateParm; // expected-error{{template non-type parameter has a different type 'long' in template redeclaration}}
+
+template<template<typename T> class X> class TemplateTemplateParm;
+
+template<template<class> class Y> class TemplateTemplateParm; // expected-note{{previous template declaration is here}} \
+      // expected-note{{previous template template parameter is here}}
+
+template<typename> class TemplateTemplateParm; // expected-error{{template parameter has a different kind in template redeclaration}}
+
+template<template<typename T, int> class X> class TemplateTemplateParm; // expected-error{{too many template parameters in template template parameter redeclaration}}
+
+template<typename T>
+struct test {}; // expected-note{{previous definition}}
+
+template<typename T>
+struct test : T {}; // expected-error{{redefinition}}
+
+class X {
+public:
+  template<typename T> class C;
+};
+
+void f() {
+  template<typename T> class X; // expected-error{{expression}}
+}
+
+template<typename T> class X1 var; // expected-error{{declared as a template}}
+
+namespace M {
+}
+
+template<typename T> class M::C3 { }; // expected-error{{out-of-line definition of 'C3' does not match any declaration in namespace 'M'}}
+
+namespace PR8001 {
+  template<typename T1>
+  struct Foo {
+    template<typename T2> class Bar;
+    typedef Bar<T1> Baz;
+
+   template<typename T2>
+   struct Bar {
+     Bar() {}
+   };
+  };
+
+  void pr8001() {
+    Foo<int>::Baz x;
+    Foo<int>::Bar<int> y(x);
+  }
+}
+
+namespace rdar9676205 {
+  template <unsigned, class _Tp> class tuple_element;
+
+  template <class _T1, class _T2> class pair;
+
+  template <class _T1, class _T2>
+  class tuple_element<0, pair<_T1, _T2> >
+  {
+    template <class _Tp>
+    struct X
+    {
+      template <class _Up, bool = X<_Up>::value>
+      struct Y
+        : public X<_Up>,
+          public Y<_Up>
+      { };
+    };
+  };
+}
+
diff --git a/clang/test/SemaTemplate/class-template-id-2.cpp b/clang/test/SemaTemplate/class-template-id-2.cpp
new file mode 100644
index 0000000..d09f524
--- /dev/null
+++ b/clang/test/SemaTemplate/class-template-id-2.cpp
@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+namespace N {
+  template<typename T> class A { };
+
+  template<> class A<int> { };
+
+  template<> class A<float>; // expected-note{{forward declaration of 'N::A<float>'}}
+
+  class B : public A<int> { };
+}
+
+class C1 : public N::A<int> { };
+
+class C2 : public N::A<float> { }; // expected-error{{base class has incomplete type}}
+
+struct D1 {
+  operator N::A<int>();
+};
+
+namespace N {
+  struct D2 {
+    operator A<int>();
+  };
+}
diff --git a/clang/test/SemaTemplate/class-template-id.cpp b/clang/test/SemaTemplate/class-template-id.cpp
new file mode 100644
index 0000000..3b02778
--- /dev/null
+++ b/clang/test/SemaTemplate/class-template-id.cpp
@@ -0,0 +1,47 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T, typename U = float> struct A { };
+
+typedef A<int> A_int;
+
+typedef float FLOAT;
+
+A<int, FLOAT> *foo(A<int> *ptr, A<int> const *ptr2, A<int, double> *ptr3) {
+  if (ptr)
+    return ptr; // okay
+  else if (ptr2)
+    return ptr2; // expected-error{{cannot initialize return object of type 'A<int, FLOAT> *' with an lvalue of type 'const A<int> *'}}
+  else {
+    return ptr3; // expected-error{{cannot initialize return object of type 'A<int, FLOAT> *' with an lvalue of type 'A<int, double> *'}}
+  }
+}
+
+template<int I> struct B;
+
+const int value = 12;
+B<17 + 2> *bar(B<(19)> *ptr1, B< (::value + 7) > *ptr2, B<19 - 3> *ptr3) {
+  if (ptr1)
+    return ptr1;
+  else if (ptr2)
+    return ptr2;
+  else
+    return ptr3; // expected-error{{cannot initialize return object of type 'B<17 + 2> *' with an lvalue of type 'B<19 - 3>}}
+}
+
+typedef B<5> B5;
+
+
+namespace N {
+  template<typename T> struct C {};
+}
+
+N::C<int> c1;
+typedef N::C<float> c2;
+
+// PR5655
+template<typename T> struct Foo { }; // expected-note{{template is declared here}}
+
+void f(void) { Foo bar; } // expected-error{{without a template argument list}}
+
+// rdar://problem/8254267
+template <typename T> class Party;
+template <> class Party<T> { friend struct Party<>; }; // expected-error {{use of undeclared identifier 'T'}}
diff --git a/clang/test/SemaTemplate/class-template-spec.cpp b/clang/test/SemaTemplate/class-template-spec.cpp
new file mode 100644
index 0000000..f9015b3
--- /dev/null
+++ b/clang/test/SemaTemplate/class-template-spec.cpp
@@ -0,0 +1,121 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T, typename U = int> struct A; // expected-note {{template is declared here}} \
+                                                 // expected-note{{explicitly specialized}}
+
+template<> struct A<double, double>; // expected-note{{forward declaration}}
+
+template<> struct A<float, float> {  // expected-note{{previous definition}}
+  int x;
+};
+
+template<> struct A<float> { // expected-note{{previous definition}}
+  int y;
+};
+
+int test_specs(A<float, float> *a1, A<float, int> *a2) {
+  return a1->x + a2->y;
+}
+
+int test_incomplete_specs(A<double, double> *a1, 
+                          A<double> *a2)
+{
+  (void)a1->x; // expected-error{{member access into incomplete type}}
+  (void)a2->x; // expected-error{{implicit instantiation of undefined template 'A<double, int>'}}
+}
+
+typedef float FLOAT;
+
+template<> struct A<float, FLOAT>;
+
+template<> struct A<FLOAT, float> { }; // expected-error{{redefinition}}
+
+template<> struct A<float, int> { }; // expected-error{{redefinition}}
+
+template<typename T, typename U = int> struct X;
+
+template <> struct X<int, int> { int foo(); }; // #1
+template <> struct X<float> { int bar(); };  // #2
+
+typedef int int_type;
+void testme(X<int_type> *x1, X<float, int> *x2) { 
+  (void)x1->foo(); // okay: refers to #1
+  (void)x2->bar(); // okay: refers to #2
+}
+
+// Make sure specializations are proper classes.
+template<>
+struct A<char> {
+  A();
+};
+
+A<char>::A() { }
+
+// Make sure we can see specializations defined before the primary template.
+namespace N{ 
+  template<typename T> struct A0;
+}
+
+namespace N {
+  template<>
+  struct A0<void> {
+    typedef void* pointer;
+  };
+}
+
+namespace N {
+  template<typename T>
+  struct A0 {
+    void foo(A0<void>::pointer p = 0);
+  };
+}
+
+// Diagnose specialization errors
+struct A<double> { }; // expected-error{{template specialization requires 'template<>'}}
+
+template<> struct ::A<double>;
+
+namespace N {
+  template<typename T> struct B; // expected-note 2{{explicitly specialized}}
+
+  template<> struct ::N::B<char>; // okay
+  template<> struct ::N::B<short>; // okay
+  template<> struct ::N::B<int>; // okay
+
+  int f(int);
+}
+
+template<> struct N::B<int> { }; // okay
+
+template<> struct N::B<float> { }; // expected-warning{{C++11 extension}}
+
+namespace M {
+  template<> struct ::N::B<short> { }; // expected-error{{class template specialization of 'B' not in a namespace enclosing 'N'}}
+
+  template<> struct ::A<long double>; // expected-error{{originally}}
+}
+
+template<> struct N::B<char> { 
+  int testf(int x) { return f(x); }
+};
+
+// PR5264
+template <typename T> class Foo;
+Foo<int>* v;
+Foo<int>& F() { return *v; }
+template <typename T> class Foo {};
+Foo<int> x;
+
+
+// Template template parameters
+template<template<class T> class Wibble>
+class Wibble<int> { }; // expected-error{{cannot specialize a template template parameter}}
+
+namespace rdar9676205 {
+  template<typename T>
+  struct X {
+    template<typename U>
+    struct X<U*> { // expected-error{{explicit specialization of 'X' in class scope}}
+    };
+  };
+
+}
diff --git a/clang/test/SemaTemplate/constexpr-instantiate.cpp b/clang/test/SemaTemplate/constexpr-instantiate.cpp
new file mode 100644
index 0000000..2f9fe0e
--- /dev/null
+++ b/clang/test/SemaTemplate/constexpr-instantiate.cpp
@@ -0,0 +1,77 @@
+// RUN: %clang_cc1 -std=c++11 -verify %s
+
+namespace UseBeforeDefinition {
+  struct A {
+    template<typename T> static constexpr T get() { return T(); }
+    // ok, not a constant expression.
+    int n = get<int>();
+  };
+
+  // ok, constant expression.
+  constexpr int j = A::get<int>();
+
+  template<typename T> constexpr int consume(T);
+  // ok, not a constant expression.
+  const int k = consume(0); // expected-note {{here}}
+
+  template<typename T> constexpr int consume(T) { return 0; }
+  // ok, constant expression.
+  constexpr int l = consume(0);
+
+  constexpr int m = k; // expected-error {{constant expression}} expected-note {{initializer of 'k'}}
+}
+
+namespace IntegralConst {
+  template<typename T> constexpr T f(T n) { return n; }
+  enum E {
+    v = f(0), w = f(1) // ok
+  };
+  static_assert(w == 1, "");
+
+  char arr[f('x')]; // ok
+  static_assert(sizeof(arr) == 'x', "");
+}
+
+namespace ConvertedConst {
+  template<typename T> constexpr T f(T n) { return n; }
+  int f() {
+    switch (f()) {
+      case f(4): return 0;
+    }
+    return 1;
+  }
+}
+
+namespace OverloadResolution {
+  template<typename T> constexpr T f(T t) { return t; }
+
+  template<int n> struct S { };
+
+  template<typename T> auto g(T t) -> S<f(sizeof(T))> &;
+  char &f(...);
+
+  template<typename T> auto h(T t[f(sizeof(T))]) -> decltype(&*t) {
+    return t;
+  }
+
+  S<4> &k = g(0);
+  int *p, *q = h(p);
+}
+
+namespace DataMember {
+  template<typename T> struct S { static const int k; };
+  const int n = S<int>::k; // expected-note {{here}}
+  template<typename T> const int S<T>::k = 0;
+  constexpr int m = S<int>::k; // ok
+  constexpr int o = n; // expected-error {{constant expression}} expected-note {{initializer of 'n'}}
+}
+
+namespace Reference {
+  const int k = 5;
+  template<typename T> struct S {
+    static volatile int &r;
+  };
+  template<typename T> volatile int &S<T>::r = const_cast<volatile int&>(k);
+  constexpr int n = const_cast<int&>(S<int>::r);
+  static_assert(n == 5, "");
+}
diff --git a/clang/test/SemaTemplate/constructor-template.cpp b/clang/test/SemaTemplate/constructor-template.cpp
new file mode 100644
index 0000000..cf3fdfb
--- /dev/null
+++ b/clang/test/SemaTemplate/constructor-template.cpp
@@ -0,0 +1,128 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+struct X0 { // expected-note{{candidate}}
+  X0(int); // expected-note{{candidate}}
+  template<typename T> X0(T); // expected-note {{candidate}}
+  template<typename T, typename U> X0(T*, U*); // expected-note {{candidate}}
+  
+  // PR4761
+  template<typename T> X0() : f0(T::foo) {} // expected-note {{candidate}}
+  int f0;
+};
+
+void accept_X0(X0);
+
+void test_X0(int i, float f) {
+  X0 x0a(i);
+  X0 x0b(f);
+  X0 x0c = i;
+  X0 x0d = f;
+  accept_X0(i);
+  accept_X0(&i);
+  accept_X0(f);
+  accept_X0(&f);
+  X0 x0e(&i, &f);
+  X0 x0f(&f, &i);
+  
+  X0 x0g(f, &i); // expected-error{{no matching constructor}}
+}
+
+template<typename T>
+struct X1 {
+  X1(const X1&);
+  template<typename U> X1(const X1<U>&);
+};
+
+template<typename T>
+struct Outer {
+  typedef X1<T> A;
+  
+  A alloc;
+  
+  explicit Outer(const A& a) : alloc(a) { }
+};
+
+void test_X1(X1<int> xi) {
+  Outer<int> oi(xi);
+  Outer<float> of(xi);
+}
+
+// PR4655
+template<class C> struct A {};
+template <> struct A<int>{A(const A<int>&);};
+struct B { A<int> x; B(B& a) : x(a.x) {} };
+
+struct X2 {
+  X2(); // expected-note{{candidate constructor}}
+  X2(X2&);	// expected-note {{candidate constructor}}
+  template<typename T> X2(T);
+};
+
+X2 test(bool Cond, X2 x2) {
+  if (Cond)
+    return x2; // okay, uses copy constructor
+  
+  return X2(); // expected-error{{no matching constructor}}
+}
+
+struct X3 {
+  template<typename T> X3(T);
+};
+
+template<> X3::X3(X3); // expected-error{{must pass its first argument by reference}}
+
+struct X4 {
+  X4();
+  ~X4();
+  X4(X4&);
+  template<typename T> X4(const T&, int = 17);
+};
+
+X4 test_X4(bool Cond, X4 x4) {
+  X4 a(x4, 17); // okay, constructor template
+  X4 b(x4); // okay, copy constructor
+  return X4();
+}
+
+// Instantiation of a non-dependent use of a constructor
+struct DefaultCtorHasDefaultArg {
+  explicit DefaultCtorHasDefaultArg(int i = 17);
+};
+
+template<typename T>
+void default_ctor_inst() {
+  DefaultCtorHasDefaultArg def;
+}
+
+template void default_ctor_inst<int>();
+
+template<typename T>
+struct X5 {
+  X5();
+  X5(const T &);
+};
+
+struct X6 {
+  template<typename T> X6(T);
+};
+
+void test_X5_X6() {
+  X5<X6> tf;
+  X5<X6> tf2(tf);
+}
+
+namespace PR8182 {
+  struct foo {
+    foo();
+    template<class T> foo(T&);
+
+  private:
+    foo(const foo&);
+  };
+
+  void test_foo() {
+    foo f1;
+    foo f2(f1);
+    foo f3 = f1;
+  }
+
+}
diff --git a/clang/test/SemaTemplate/copy-ctor-assign.cpp b/clang/test/SemaTemplate/copy-ctor-assign.cpp
new file mode 100644
index 0000000..ae6dc9c
--- /dev/null
+++ b/clang/test/SemaTemplate/copy-ctor-assign.cpp
@@ -0,0 +1,52 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Make sure that copy constructors and assignment operators are properly 
+// generated when there is a matching 
+
+// PR5072
+template<typename T>
+struct X {
+  template<typename U> 
+  X(const X<U>& other) 
+    : value(other.value + 1) { } // expected-error{{binary expression}}
+
+  template<typename U> 
+  X& operator=(const X<U>& other)  {
+    value = other.value + 1; // expected-error{{binary expression}}
+    return *this;
+  }
+  
+  T value;
+};
+
+struct Y {};
+
+X<int Y::*> test0(X<int Y::*> x) { return x; }
+X<int> test1(X<long> x) { return x; }
+
+
+X<int> test2(X<int Y::*> x) { 
+  return x; // expected-note{{instantiation}}
+}
+
+void test3(X<int> &x, X<int> xi, X<long> xl, X<int Y::*> xmptr) {
+  x = xi;
+  x = xl;
+  x = xmptr; // expected-note{{instantiation}}
+}
+
+struct X1 {
+  X1 &operator=(const X1&);
+};
+
+template<typename T>
+struct X2 : X1 {
+  template<typename U> X2 &operator=(const U&);
+};
+
+struct X3 : X2<int> {
+};
+
+void test_X2(X3 &to, X3 from) {
+  to = from;
+}
diff --git a/clang/test/SemaTemplate/crash-10438657.cpp b/clang/test/SemaTemplate/crash-10438657.cpp
new file mode 100644
index 0000000..2ee64bd
--- /dev/null
+++ b/clang/test/SemaTemplate/crash-10438657.cpp
@@ -0,0 +1,15 @@
+// RUN: not %clang_cc1 -fsyntax-only %s 2> %t
+// RUN: FileCheck %s < %t
+// CHECK: 10 errors
+template<typename _CharT>
+class collate : public locale::facet {
+
+protected:
+virtual ~collate() {}
+  class wxObject;
+  class __attribute__ ((visibility("default"))) wxGDIRefData 
+    : public wxObjectRefData {};
+  class __attribute__ ((visibility("default"))) wxGDIObject : public wxObject { \
+      public:
+      virtual bool IsOk() const {
+        return m_refData && static_cast<wxGDIRefData *>(m_refData)->IsOk(); 
diff --git a/clang/test/SemaTemplate/crash-8204126.cpp b/clang/test/SemaTemplate/crash-8204126.cpp
new file mode 100644
index 0000000..eb96560
--- /dev/null
+++ b/clang/test/SemaTemplate/crash-8204126.cpp
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+struct A
+{
+  template<int> template<typename T> friend void foo(T) {} // expected-error{{extraneous template parameter list}}
+  void bar() { foo(0); } // expected-error{{use of undeclared identifier 'foo'}}
+};
diff --git a/clang/test/SemaTemplate/current-instantiation.cpp b/clang/test/SemaTemplate/current-instantiation.cpp
new file mode 100644
index 0000000..ccef811
--- /dev/null
+++ b/clang/test/SemaTemplate/current-instantiation.cpp
@@ -0,0 +1,237 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// This test concerns the identity of dependent types within the
+// canonical type system, specifically focusing on the difference
+// between members of the current instantiation and membmers of an
+// unknown specialization. This considers C++ [temp.type], which
+// specifies type equivalence within a template, and C++0x
+// [temp.dep.type], which defines what it means to be a member of the
+// current instantiation.
+
+template<typename T, typename U>
+struct X0 {
+  typedef T T_type;
+  typedef U U_type;
+
+  void f0(T&); // expected-note{{previous}}
+  void f0(typename X0::U_type&);
+  void f0(typename X0::T_type&); // expected-error{{redecl}}
+
+  void f1(T&); // expected-note{{previous}}
+  void f1(typename X0::U_type&);
+  void f1(typename X0<T, U>::T_type&); // expected-error{{redecl}}
+
+  void f2(T&); // expected-note{{previous}}
+  void f2(typename X0::U_type&);
+  void f2(typename X0<T_type, U_type>::T_type&); // expected-error{{redecl}}
+
+  void f3(T&); // expected-note{{previous}}
+  void f3(typename X0::U_type&);
+  void f3(typename ::X0<T_type, U_type>::T_type&); // expected-error{{redecl}}
+
+  struct X1 {
+    typedef T my_T_type;
+
+    void g0(T&); // expected-note{{previous}}
+    void g0(typename X0::U_type&);
+    void g0(typename X0::T_type&); // expected-error{{redecl}}
+
+    void g1(T&); // expected-note{{previous}}
+    void g1(typename X0::U_type&);
+    void g1(typename X0<T, U>::T_type&); // expected-error{{redecl}}
+    
+    void g2(T&); // expected-note{{previous}}
+    void g2(typename X0::U_type&);
+    void g2(typename X0<T_type, U_type>::T_type&); // expected-error{{redecl}}
+    
+    void g3(T&); // expected-note{{previous}}
+    void g3(typename X0::U_type&);
+    void g3(typename ::X0<T_type, U_type>::T_type&); // expected-error{{redecl}}
+
+    void g4(T&); // expected-note{{previous}}
+    void g4(typename X0::U_type&);
+    void g4(typename X1::my_T_type&); // expected-error{{redecl}}
+
+    void g5(T&); // expected-note{{previous}}
+    void g5(typename X0::U_type&);
+    void g5(typename X0::X1::my_T_type&); // expected-error{{redecl}}
+
+    void g6(T&); // expected-note{{previous}}
+    void g6(typename X0::U_type&);
+    void g6(typename X0<T, U>::X1::my_T_type&); // expected-error{{redecl}}
+
+    void g7(T&); // expected-note{{previous}}
+    void g7(typename X0::U_type&);
+    void g7(typename ::X0<typename X1::my_T_type, U_type>::X1::my_T_type&); // expected-error{{redecl}}
+
+    void g8(T&); // expected-note{{previous}}
+    void g8(typename X0<U, T_type>::T_type&);
+    void g8(typename ::X0<typename X0<T_type, U>::X1::my_T_type, U_type>::X1::my_T_type&); // expected-error{{redecl}}
+  };
+};
+
+
+template<typename T, typename U>
+struct X0<T*, U*> {
+  typedef T T_type;
+  typedef U U_type;
+  typedef T* Tptr;
+  typedef U* Uptr;
+  
+  void f0(T&); // expected-note{{previous}}
+  void f0(typename X0::U_type&);
+  void f0(typename X0::T_type&); // expected-error{{redecl}}
+  
+  void f1(T&); // expected-note{{previous}}
+  void f1(typename X0::U_type&);
+  void f1(typename X0<T*, U*>::T_type&); // expected-error{{redecl}}
+  
+  void f2(T&); // expected-note{{previous}}
+  void f2(typename X0::U_type&);
+  void f2(typename X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
+  
+  void f3(T&); // expected-note{{previous}}
+  void f3(typename X0::U_type&);
+  void f3(typename ::X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
+
+  void f4(T&); // expected-note{{previous}}
+  void f4(typename X0::U_type&);
+  void f4(typename ::X0<Tptr, Uptr>::T_type&); // expected-error{{redecl}}
+  
+  void f5(X0*); // expected-note{{previous}}
+  void f5(::X0<T, U>*);
+  void f5(::X0<T*, U*>*); // expected-error{{redecl}}
+  
+  struct X2 {
+    typedef T my_T_type;
+    
+    void g0(T&); // expected-note{{previous}}
+    void g0(typename X0::U_type&);
+    void g0(typename X0::T_type&); // expected-error{{redecl}}
+    
+    void g1(T&); // expected-note{{previous}}
+    void g1(typename X0::U_type&);
+    void g1(typename X0<T*, U*>::T_type&); // expected-error{{redecl}}
+    
+    void g2(T&); // expected-note{{previous}}
+    void g2(typename X0::U_type&);
+    void g2(typename X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
+    
+    void g3(T&); // expected-note{{previous}}
+    void g3(typename X0::U_type&);
+    void g3(typename ::X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
+    
+    void g4(T&); // expected-note{{previous}}
+    void g4(typename X0::U_type&);
+    void g4(typename X2::my_T_type&); // expected-error{{redecl}}
+    
+    void g5(T&); // expected-note{{previous}}
+    void g5(typename X0::U_type&);
+    void g5(typename X0::X2::my_T_type&); // expected-error{{redecl}}
+    
+    void g6(T&); // expected-note{{previous}}
+    void g6(typename X0::U_type&);
+    void g6(typename X0<T*, U*>::X2::my_T_type&); // expected-error{{redecl}}
+    
+    void g7(T&); // expected-note{{previous}}
+    void g7(typename X0::U_type&);
+    void g7(typename ::X0<typename X2::my_T_type*, U_type*>::X2::my_T_type&); // expected-error{{redecl}}
+    
+    void g8(T&); // expected-note{{previous}}
+    void g8(typename X0<U, T_type>::T_type&);
+    void g8(typename ::X0<typename X0<T_type*, U*>::X2::my_T_type*, U_type*>::X2::my_T_type&); // expected-error{{redecl}}
+  };
+};
+
+template<typename T>
+struct X1 {
+  static int *a;
+  void f(float *b) {
+    X1<T>::a = b; // expected-error{{incompatible}}
+    X1<T*>::a = b;
+  }
+};
+
+namespace ConstantInCurrentInstantiation {
+  template<typename T>
+  struct X {
+    static const int value = 2;
+    static int array[value];
+  };
+
+  template<typename T> const int X<T>::value;
+
+  template<typename T>
+  int X<T>::array[X<T>::value] = { 1, 2 };
+}
+
+namespace Expressions {
+  template <bool b>
+  struct Bool {
+    enum anonymous_enum { value = b };
+  };
+  struct True : public Bool<true> {};
+  struct False : public Bool<false> {};
+
+  template <typename T1, typename T2>
+  struct Is_Same : public False {};
+  template <typename T>
+  struct Is_Same<T, T> : public True {};
+
+  template <bool b, typename T = void>
+  struct Enable_If {};
+  template <typename T>
+  struct Enable_If<true, T>  {
+    typedef T type;
+  };
+
+  template <typename T>
+  class Class {
+  public:
+    template <typename U>
+    typename Enable_If<Is_Same<U, Class>::value, void>::type
+    foo();
+  };
+
+
+  template <typename T>
+  template <typename U>
+  typename Enable_If<Is_Same<U, Class<T> >::value, void>::type
+  Class<T>::foo() {}
+}
+
+namespace PR9255 {
+  template<typename T>
+  class X0  {
+  public:
+    class Inner1;
+
+    class Inner2  {
+    public:
+      void f()
+      {
+        Inner1::f.g();
+      }
+    };
+  };
+}
+
+namespace rdar10194295 {
+  template<typename XT>
+  class X {
+  public:
+    enum Enum { Yes, No };
+    template<Enum> void foo();
+    template<Enum> class Inner;
+  };
+
+  template<typename XT>
+  template<typename X<XT>::Enum>
+  void X<XT>::foo()
+  {
+  }
+
+  template<typename XT>
+  template<typename X<XT>::Enum>
+  class X<XT>::Inner { };
+}
diff --git a/clang/test/SemaTemplate/deduction-crash.cpp b/clang/test/SemaTemplate/deduction-crash.cpp
new file mode 100644
index 0000000..cf3899f
--- /dev/null
+++ b/clang/test/SemaTemplate/deduction-crash.cpp
@@ -0,0 +1,89 @@
+// RUN: %clang_cc1 -fsyntax-only %s 2>&1| FileCheck %s
+
+// Note that the error count below doesn't matter. We just want to
+// make sure that the parser doesn't crash.
+// CHECK: 13 errors
+
+// PR7511
+template<a>
+struct int_;
+
+template<a>
+template<int,typename T1,typename>
+struct ac
+{
+  typedef T1 ae
+};
+
+template<class>struct aaa
+{
+  typedef ac<1,int,int>::ae ae
+};
+
+template<class>
+struct state_machine
+{
+  typedef aaa<int>::ae aaa;
+  int start()
+  {
+    ant(0);
+  }
+  
+  template<class>
+  struct region_processing_helper
+  {
+    template<class,int=0>
+    struct In;
+    
+    template<int my>
+    struct In<a::int_<aaa::a>,my>;
+        
+    template<class Event>
+    int process(Event)
+    {
+      In<a::int_<0> > a;
+    }
+  }
+  template<class Event>
+  int ant(Event)
+  {
+    region_processing_helper<int>* helper;
+    helper->process(0)
+  }
+};
+
+int a()
+{
+  state_machine<int> p;
+  p.ant(0);
+}
+
+// PR9974
+template <int> struct enable_if;
+template <class > struct remove_reference ;
+template <class _Tp> struct remove_reference<_Tp&> ;
+
+template <class > struct __tuple_like;
+
+template <class _Tp, class _Up, int = __tuple_like<typename remove_reference<_Tp>::type>::value> 
+struct __tuple_convertible;
+
+struct pair
+{
+template<class _Tuple, int = enable_if<__tuple_convertible<_Tuple, pair>::value>::type> 
+pair(_Tuple&& );
+};
+
+template <class> struct basic_ostream;
+
+template <int> 
+void endl( ) ;
+
+extern basic_ostream<char> cout;
+
+int operator<<( basic_ostream<char> , pair ) ;
+
+void register_object_imp ( )
+{
+cout << endl<1>;
+}
diff --git a/clang/test/SemaTemplate/deduction.cpp b/clang/test/SemaTemplate/deduction.cpp
new file mode 100644
index 0000000..aecb5ee
--- /dev/null
+++ b/clang/test/SemaTemplate/deduction.cpp
@@ -0,0 +1,164 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Template argument deduction with template template parameters.
+template<typename T, template<T> class A> 
+struct X0 {
+  static const unsigned value = 0;
+};
+
+template<template<int> class A>
+struct X0<int, A> {
+  static const unsigned value = 1;
+};
+
+template<int> struct X0i;
+template<long> struct X0l;
+int array_x0a[X0<long, X0l>::value == 0? 1 : -1];
+int array_x0b[X0<int, X0i>::value == 1? 1 : -1];
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+template<typename T> struct allocator { };
+template<typename T, typename Alloc = allocator<T> > struct vector {};
+
+// Fun with meta-lambdas!
+struct _1 {};
+struct _2 {};
+
+// Replaces all occurrences of _1 with Arg1 and _2 with Arg2 in T.
+template<typename T, typename Arg1, typename Arg2>
+struct Replace {
+  typedef T type;
+};
+
+// Replacement of the whole type.
+template<typename Arg1, typename Arg2>
+struct Replace<_1, Arg1, Arg2> {
+  typedef Arg1 type;
+};
+
+template<typename Arg1, typename Arg2>
+struct Replace<_2, Arg1, Arg2> {
+  typedef Arg2 type;
+};
+
+// Replacement through cv-qualifiers
+template<typename T, typename Arg1, typename Arg2>
+struct Replace<const T, Arg1, Arg2> {
+  typedef typename Replace<T, Arg1, Arg2>::type const type;
+};
+
+// Replacement of templates
+template<template<typename> class TT, typename T1, typename Arg1, typename Arg2>
+struct Replace<TT<T1>, Arg1, Arg2> {
+  typedef TT<typename Replace<T1, Arg1, Arg2>::type> type;
+};
+
+template<template<typename, typename> class TT, typename T1, typename T2,
+         typename Arg1, typename Arg2>
+struct Replace<TT<T1, T2>, Arg1, Arg2> {
+  typedef TT<typename Replace<T1, Arg1, Arg2>::type,
+             typename Replace<T2, Arg1, Arg2>::type> type;
+};
+
+// Just for kicks...
+template<template<typename, typename> class TT, typename T1,
+         typename Arg1, typename Arg2>
+struct Replace<TT<T1, _2>, Arg1, Arg2> {
+  typedef TT<typename Replace<T1, Arg1, Arg2>::type, Arg2> type;
+};
+
+int array0[is_same<Replace<_1, int, float>::type, int>::value? 1 : -1];
+int array1[is_same<Replace<const _1, int, float>::type, const int>::value? 1 : -1];
+int array2[is_same<Replace<vector<_1>, int, float>::type, vector<int> >::value? 1 : -1];
+int array3[is_same<Replace<vector<const _1>, int, float>::type, vector<const int> >::value? 1 : -1];
+int array4[is_same<Replace<vector<int, _2>, double, float>::type, vector<int, float> >::value? 1 : -1];
+
+// PR5911
+template <typename T, int N> void f(const T (&a)[N]);
+int iarr[] = { 1 };
+void test_PR5911() { f(iarr); }
+
+// Must not examine base classes of incomplete type during template argument
+// deduction.
+namespace PR6257 {
+  template <typename T> struct X {
+    template <typename U> X(const X<U>& u);
+  };
+  struct A;
+  void f(A& a);
+  void f(const X<A>& a);
+  void test(A& a) { (void)f(a); }
+}
+
+// PR7463
+namespace PR7463 {
+  const int f ();
+  template <typename T_> void g (T_&); // expected-note{{T_ = int}}
+  void h (void) { g(f()); } // expected-error{{no matching function for call}}
+}
+
+namespace test0 {
+  template <class T> void make(const T *(*fn)()); // expected-note {{candidate template ignored: can't deduce a type for 'T' which would make 'const T' equal 'char'}}
+  char *char_maker();
+  void test() {
+    make(char_maker); // expected-error {{no matching function for call to 'make'}}
+  }
+}
+
+namespace test1 {
+  template<typename T> void foo(const T a[3][3]);
+  void test() {
+    int a[3][3];
+    foo(a);
+  }
+}
+
+// PR7708
+namespace test2 {
+  template<typename T> struct Const { typedef void const type; };
+
+  template<typename T> void f(T, typename Const<T>::type*);
+  template<typename T> void f(T, void const *);
+
+  void test() {
+    void *p = 0;
+    f(0, p);
+  }
+}
+
+// rdar://problem/8537391
+namespace test3 {
+  struct Foo {
+    template <void F(char)> static inline void foo();
+  };
+
+  class Bar {
+    template<typename T> static inline void wobble(T ch);
+
+  public:
+    static void madness() {
+      Foo::foo<wobble<char> >();
+    }
+  };
+}
+
+// Verify that we can deduce enum-typed arguments correctly.
+namespace test14 {
+  enum E { E0, E1 };
+  template <E> struct A {};
+  template <E e> void foo(const A<e> &a) {}
+
+  void test() {
+    A<E0> a;
+    foo(a);
+  }
+}
diff --git a/clang/test/SemaTemplate/default-arguments-cxx0x.cpp b/clang/test/SemaTemplate/default-arguments-cxx0x.cpp
new file mode 100644
index 0000000..7714313
--- /dev/null
+++ b/clang/test/SemaTemplate/default-arguments-cxx0x.cpp
@@ -0,0 +1,26 @@
+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
+
+// Test default template arguments for function templates.
+template<typename T = int>
+void f0();
+
+template<typename T>
+void f0();
+
+void g0() {
+  f0(); // okay!
+} 
+
+template<typename T, int N = T::value>
+int &f1(T);
+
+float &f1(...);
+
+struct HasValue {
+  static const int value = 17;
+};
+
+void g1() {
+  float &fr = f1(15);
+  int &ir = f1(HasValue());
+}
diff --git a/clang/test/SemaTemplate/default-arguments.cpp b/clang/test/SemaTemplate/default-arguments.cpp
new file mode 100644
index 0000000..6391369
--- /dev/null
+++ b/clang/test/SemaTemplate/default-arguments.cpp
@@ -0,0 +1,138 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T, int N = 2> struct X; // expected-note{{template is declared here}}
+
+X<int, 1> *x1;
+X<int> *x2;
+
+X<> *x3; // expected-error{{too few template arguments for class template 'X'}}
+
+template<typename U = float, int M> struct X;
+
+X<> *x4;
+
+template<typename T = int> struct Z { };
+template struct Z<>;
+
+// PR4362
+template<class T> struct a { };
+template<> struct a<int> { static const bool v = true; };
+
+template<class T, bool = a<T>::v> struct p { }; // expected-error {{no member named 'v'}}
+
+template struct p<bool>; // expected-note {{in instantiation of default argument for 'p<bool>' required here}}
+template struct p<int>;
+
+// PR5187
+template<typename T, typename U>
+struct A;
+
+template<typename T, typename U = T>
+struct A;
+
+template<typename T, typename U>
+struct A {
+  void f(A<T>);
+};
+
+template<typename T>
+struct B { };
+
+template<>
+struct B<void> {
+  typedef B<void*> type;
+};
+
+// Nested default arguments for template parameters.
+template<typename T> struct X1 { };
+
+template<typename T>
+struct X2 {
+  template<typename U = typename X1<T>::type> // expected-error{{no type named}}
+  struct Inner1 { };
+  
+  template<T Value = X1<T>::value> // expected-error{{no member named 'value'}}
+  struct NonType1 { };
+  
+  template<T Value>
+  struct Inner2 { };
+  
+  template<typename U>
+  struct Inner3 {
+    template<typename X = T, typename V = U>
+    struct VeryInner { };
+    
+    template<T Value1 = sizeof(T), T Value2 = sizeof(U), 
+             T Value3 = Value1 + Value2>
+    struct NonType2 { };
+  };
+};
+
+X2<int> x2i;
+X2<int>::Inner1<float> x2iif;
+
+X2<int>::Inner1<> x2bad; // expected-note{{instantiation of default argument}}
+
+X2<int>::NonType1<'a'> x2_nontype1;
+X2<int>::NonType1<> x2_nontype1_bad; // expected-note{{instantiation of default argument}}
+
+// Check multi-level substitution into template type arguments
+X2<int>::Inner3<float>::VeryInner<> vi;
+X2<char>::Inner3<int>::NonType2<> x2_deep_nontype;
+
+template<typename T, typename U>
+struct is_same { static const bool value = false; };
+
+template<typename T>
+struct is_same<T, T> { static const bool value = true; };
+
+int array1[is_same<__typeof__(vi), 
+               X2<int>::Inner3<float>::VeryInner<int, float> >::value? 1 : -1];
+
+int array2[is_same<__typeof(x2_deep_nontype),
+                   X2<char>::Inner3<int>::NonType2<sizeof(char), sizeof(int), 
+                                    sizeof(char)+sizeof(int)> >::value? 1 : -1];
+
+// Template template parameter defaults
+template<template<typename T> class X = X2> struct X3 { };
+int array3[is_same<X3<>, X3<X2> >::value? 1 : -1];
+
+struct add_pointer {
+  template<typename T>
+  struct apply {
+    typedef T* type;
+  };
+};
+
+template<typename T, template<typename> class X = T::template apply>
+  struct X4;
+int array4[is_same<X4<add_pointer>, 
+                   X4<add_pointer, add_pointer::apply> >::value? 1 : -1];
+
+template<int> struct X5 {}; // expected-note{{has a different type 'int'}}
+template<long> struct X5b {};
+template<typename T, 
+         template<T> class B = X5> // expected-error{{template template argument has different}} \
+                                   // expected-note{{previous non-type template parameter}}
+  struct X6 {};
+
+X6<int> x6a;
+X6<long> x6b; // expected-note{{while checking a default template argument}}
+X6<long, X5b> x6c;
+
+
+template<template<class> class X = B<int> > struct X7; // expected-error{{must be a class template}}
+
+namespace PR9643 {
+  template<typename T> class allocator {};
+  template<typename T, typename U = allocator<T> > class vector {};
+
+  template<template<typename U, typename = allocator<U> > class container,
+           typename DT>
+  container<DT> initializer(const DT& d) {
+    return container<DT>();
+  }
+
+  void f() {
+    vector<int, allocator<int> > v = initializer<vector>(5);
+  }
+}
diff --git a/clang/test/SemaTemplate/default-expr-arguments-2.cpp b/clang/test/SemaTemplate/default-expr-arguments-2.cpp
new file mode 100644
index 0000000..378999d
--- /dev/null
+++ b/clang/test/SemaTemplate/default-expr-arguments-2.cpp
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -ast-dump %s 2>&1 | FileCheck %s
+
+// This is a wacky test to ensure that we're actually instantiating
+// the default arguments of the constructor when the function type is
+// otherwise non-dependent.
+namespace PR6733 {
+  template <class T>
+  class bar {
+  public: enum { kSomeConst = 128 };
+    bar(int x = kSomeConst) {}
+  };
+  
+  // CHECK: void f()
+  void f() {
+    // CHECK: bar<int> tmp =
+    // CHECK: CXXDefaultArgExpr{{.*}}'int'
+    bar<int> tmp;
+  }
+}
diff --git a/clang/test/SemaTemplate/default-expr-arguments.cpp b/clang/test/SemaTemplate/default-expr-arguments.cpp
new file mode 100644
index 0000000..1eefa9f
--- /dev/null
+++ b/clang/test/SemaTemplate/default-expr-arguments.cpp
@@ -0,0 +1,305 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T>
+class C { C(int a0 = 0); };
+
+template<>
+C<char>::C(int a0);
+
+struct S { }; // expected-note 3 {{candidate constructor (the implicit copy constructor)}}
+
+template<typename T> void f1(T a, T b = 10) { } // expected-error{{no viable conversion}} \
+// expected-note{{passing argument to parameter 'b' here}}
+
+template<typename T> void f2(T a, T b = T()) { }
+
+template<typename T> void f3(T a, T b = T() + T()); // expected-error{{invalid operands to binary expression ('S' and 'S')}}
+
+void g() {
+  f1(10);
+  f1(S()); // expected-note{{in instantiation of default function argument expression for 'f1<S>' required here}}
+  
+  f2(10);
+  f2(S());
+  
+  f3(10);
+  f3(S()); // expected-note{{in instantiation of default function argument expression for 'f3<S>' required here}}
+}
+
+template<typename T> struct F {
+  F(T t = 10); // expected-error{{no viable conversion}} \
+  // expected-note{{passing argument to parameter 't' here}}
+  void f(T t = 10); // expected-error{{no viable conversion}} \
+  // expected-note{{passing argument to parameter 't' here}}
+};
+
+struct FD : F<int> { };
+
+void g2() {
+  F<int> f;
+  FD fd;
+}
+
+void g3(F<int> f, F<struct S> s) {
+  f.f();
+  s.f(); // expected-note{{in instantiation of default function argument expression for 'f<S>' required here}}
+  
+  F<int> f2;
+  F<S> s2; // expected-note{{in instantiation of default function argument expression for 'F<S>' required here}}
+}
+
+template<typename T> struct G {
+  G(T) {}
+};
+
+void s(G<int> flags = 10) { }
+
+// Test default arguments
+template<typename T>
+struct X0 {
+  void f(T = T()); // expected-error{{no matching}}
+};
+
+template<typename U>
+void X0<U>::f(U) { }
+
+void test_x0(X0<int> xi) {
+  xi.f();
+  xi.f(17);
+}
+
+struct NotDefaultConstructible { // expected-note 2{{candidate}}
+  NotDefaultConstructible(int); // expected-note 2{{candidate}}
+};
+
+void test_x0_not_default_constructible(X0<NotDefaultConstructible> xn) {
+  xn.f(NotDefaultConstructible(17));
+  xn.f(42);
+  xn.f(); // expected-note{{in instantiation of default function argument}}
+}
+
+template<typename T>
+struct X1 {
+  typedef T value_type;
+  X1(const value_type& value = value_type());
+};
+
+void test_X1() {
+  X1<int> x1;
+}
+
+template<typename T>
+struct X2 {
+  void operator()(T = T()); // expected-error{{no matching}}
+};
+
+void test_x2(X2<int> x2i, X2<NotDefaultConstructible> x2n) {
+  x2i();
+  x2i(17);
+  x2n(NotDefaultConstructible(17));
+  x2n(); // expected-note{{in instantiation of default function argument}}
+}
+
+// PR5283
+namespace PR5283 {
+template<typename T> struct A {
+  A(T = 1); // expected-error 3 {{cannot initialize a parameter of type 'int *' with an rvalue of type 'int'}} \
+  // expected-note 3{{passing argument to parameter here}}
+};
+
+struct B : A<int*> { 
+  B();
+};
+B::B() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}
+
+struct C : virtual A<int*> {
+  C();
+};
+C::C() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}
+
+struct D {
+  D();
+  
+  A<int*> a;
+};
+D::D() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}
+}
+
+// PR5301
+namespace pr5301 {
+  void f(int, int = 0);
+
+  template <typename T>
+  void g(T, T = 0);
+
+  template <int I>
+  void i(int a = I);
+
+  template <typename T>
+  void h(T t) {
+    f(0);
+    g(1);
+    g(t);
+    i<2>();
+  }
+
+  void test() {
+    h(0);
+  }
+}
+
+// PR5810
+namespace PR5810 {
+  template<typename T>
+  struct allocator {
+    allocator() { int a[sizeof(T) ? -1 : -1]; } // expected-error2 {{array with a negative size}}
+  };
+  
+  template<typename T>
+  struct vector {
+    vector(const allocator<T>& = allocator<T>()) {} // expected-note2 {{instantiation of}}
+  };
+  
+  struct A { };
+  struct B { };
+
+  template<typename>
+  void FilterVTs() {
+    vector<A> Result;
+  }
+  
+  void f() {
+    vector<A> Result;
+  }
+
+  template<typename T>
+  struct X {
+    vector<B> bs;
+    X() { }
+  };
+
+  void f2() {
+    X<float> x; // expected-note{{member function}}
+  }
+}
+
+template<typename T> void f4(T, int = 17);
+template<> void f4<int>(int, int);
+
+void f4_test(int i) {
+  f4(i);
+}
+
+// Instantiate for initialization
+namespace InstForInit {
+  template<typename T>
+  struct Ptr {
+    typedef T* type;
+    Ptr(type);
+  };
+
+  template<typename T>
+  struct Holder {
+    Holder(int i, Ptr<T> ptr = 0);
+  };
+
+  void test_holder(int i) {
+    Holder<int> h(i);
+  }
+};
+
+namespace PR5810b {
+  template<typename T>
+  T broken() {
+    T t;
+    double**** not_it = t;
+  }
+
+  void f(int = broken<int>());
+  void g() { f(17); }
+}
+
+namespace PR5810c {
+  template<typename T>
+  struct X { 
+    X() { 
+      T t;
+      double *****p = t; // expected-error{{cannot initialize a variable of type 'double *****' with an lvalue of type 'int'}}
+    }
+    X(const X&) { }
+  };
+
+  struct Y : X<int> { // expected-note{{instantiation of}}
+  };
+
+  void f(Y y = Y());
+
+  void g() { f(); }
+}
+
+namespace PR8127 {
+  template< typename T > class PointerClass {
+  public:
+    PointerClass( T * object_p ) : p_( object_p ) {
+      p_->acquire();
+    }
+  private:    
+    T * p_;
+  };
+
+  class ExternallyImplementedClass;
+
+  class MyClass {
+    void foo( PointerClass<ExternallyImplementedClass> = 0 );
+  };
+}
+
+namespace rdar8427926 {
+  template<typename T>
+  struct Boom {
+    ~Boom() {
+      T t;
+      double *******ptr = t; // expected-error 2{{cannot initialize}}
+    }
+  };
+
+  Boom<float> *bfp;
+
+  struct X {
+    void f(Boom<int> = Boom<int>()) { } // expected-note{{requested here}}
+    void g(int x = (delete bfp, 0)); // expected-note{{requested here}}
+  };
+
+  void test(X *x) {
+    x->f();
+    x->g();
+  }
+}
+
+namespace PR8401 {
+  template<typename T> 
+  struct A { 
+    A() { T* x = 1; } // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
+  };
+
+  template<typename T>
+  struct B {
+    B(const A<T>& a = A<T>()); // expected-note{{in instantiation of}}
+  };
+
+  void f(B<int> b = B<int>());
+
+  void g() {
+    f();
+  }
+}
+
+namespace PR12581 {
+  const int a = 0;
+  template < typename > struct A;
+  template < typename MatrixType, int =
+  A < MatrixType >::Flags ? : A < MatrixType >::Flags & a > class B;
+  void
+  fn1 ()
+  {
+  }
+}
diff --git a/clang/test/SemaTemplate/delegating-constructors.cpp b/clang/test/SemaTemplate/delegating-constructors.cpp
new file mode 100644
index 0000000..e177b50
--- /dev/null
+++ b/clang/test/SemaTemplate/delegating-constructors.cpp
@@ -0,0 +1,31 @@
+// RUN: %clang_cc1 -fsyntax-only -std=c++11 %s -verify 
+
+namespace PR10457 {
+
+  class string
+  {
+    string(const char* str, unsigned);
+
+  public:
+    template <unsigned N>
+    string(const char (&str)[N])
+      : string(str) {} // expected-error{{constructor for 'string<6>' creates a delegation cycle}}
+  };
+
+  void f() {
+    string s("hello");
+  }
+
+  struct Foo {
+   Foo(int) { }
+
+
+   template <typename T>
+   Foo(T, int i) : Foo(i) { }
+};
+
+  void test_Foo()
+  {
+    Foo f(1, 1);
+  }
+}
diff --git a/clang/test/SemaTemplate/dependent-base-classes.cpp b/clang/test/SemaTemplate/dependent-base-classes.cpp
new file mode 100644
index 0000000..895eacc
--- /dev/null
+++ b/clang/test/SemaTemplate/dependent-base-classes.cpp
@@ -0,0 +1,137 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T, typename U>
+struct X0 : T::template apply<U> { 
+  X0(U u) : T::template apply<U>(u) { }
+};
+
+template<typename T, typename U>
+struct X1 : T::apply<U> { }; // expected-error{{use 'template' keyword to treat 'apply' as a dependent template name}}
+
+template<typename T>
+struct X2 : vector<T> { }; // expected-error{{unknown template name 'vector'}}
+
+namespace PR6031 {
+  template<typename T>
+  struct A;
+
+  template <class X>
+  struct C { };
+
+  template <class TT>
+  struct II {
+    typedef typename A<TT>::type type;
+  };
+
+  template <class TT>
+  struct FI : II<TT>
+  {
+    C<typename FI::type> a;
+  };
+
+  template <class TT>
+  struct FI2
+  {
+    C<typename FI2::type> a; // expected-error{{no type named 'type' in 'FI2<TT>'}} \
+        // expected-error{{C++ requires a type specifier for all declarations}}
+  };
+
+  template<typename T>
+  struct Base {
+    class Nested { };
+    template<typename U> struct MemberTemplate { };
+    int a;
+  };
+
+  template<typename T>
+  struct HasDepBase : Base<T> {
+    int foo() {
+      class HasDepBase::Nested nested;
+      typedef typename HasDepBase::template MemberTemplate<T>::type type;
+      return HasDepBase::a;
+    }
+  };
+
+  template<typename T>
+  struct NoDepBase {
+    int foo() {
+      class NoDepBase::Nested nested; // expected-error{{no class named 'Nested' in 'NoDepBase<T>'}}
+      typedef typename NoDepBase::template MemberTemplate<T>::type type; // expected-error{{'MemberTemplate' following the 'template' keyword does not refer to a template}} \
+      // FIXME: expected-error{{unqualified-id}}
+      return NoDepBase::a; // expected-error{{no member named 'a' in 'NoDepBase<T>'}}
+    }
+  };
+}
+
+namespace Ambig {
+  template<typename T>
+  struct Base1 {
+    typedef int type; // expected-note{{member found by ambiguous name lookup}}
+  };
+
+  struct Base2 {
+    typedef float type; // expected-note{{member found by ambiguous name lookup}}
+  };
+
+  template<typename T>
+  struct Derived : Base1<T>, Base2 {
+    typedef typename Derived::type type; // expected-error{{member 'type' found in multiple base classes of different types}}
+    type *foo(float *fp) { return fp; }
+  };
+
+  Derived<int> di; // expected-note{{instantiation of}}
+}
+
+namespace PR6081 {
+  template<typename T>
+  struct A { };
+
+  template<typename T>
+  class B : public A<T> 
+  {
+  public:
+    template< class X >
+    void f0(const X & k)
+    {
+      this->template f1<int>()(k);
+    }
+  };
+
+  template<typename T>
+  class C
+  {
+  public:
+    template< class X >
+    void f0(const X & k)
+    {
+      this->template f1<int>()(k); // expected-error{{'f1' following the 'template' keyword does not refer to a template}} \
+      // FIXME: expected-error{{unqualified-id}} \
+      // expected-error{{function-style cast or type construction}} \
+      // expected-error{{expected expression}}
+    }
+  };
+}
+
+namespace PR6413 {
+  template <typename T> class Base_A { };
+  
+  class Base_B { };
+  
+  template <typename T>
+  class Derived
+    : public virtual Base_A<T>
+    , public virtual Base_B
+  { };
+}
+
+namespace PR5812 {
+  template <class T> struct Base { 
+    Base* p; 
+  }; 
+
+  template <class T> struct Derived: public Base<T> { 
+    typename Derived::Base* p; // meaning Derived::Base<T> 
+  };
+
+  Derived<int> di;
+}
diff --git a/clang/test/SemaTemplate/dependent-base-member-init.cpp b/clang/test/SemaTemplate/dependent-base-member-init.cpp
new file mode 100644
index 0000000..1d4fed3
--- /dev/null
+++ b/clang/test/SemaTemplate/dependent-base-member-init.cpp
@@ -0,0 +1,68 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// PR4381
+template<class T> struct X {};
+template<typename T> struct Y : public X<T>::X { };
+
+// PR4621
+class A1 {
+  A1(int x) {}
+};
+template<class C> class B1 : public A1 {
+  B1(C x) : A1(x.x) {}
+};
+class A2 { A2(int x, int y); };
+template <class C> class B2 {
+  A2 x;
+  B2(C x) : x(x.x, x.y) {}
+};
+template <class C> class B3 {
+  C x;
+  B3() : x(1,2) {}
+};
+
+// PR4627
+template<typename _Container> class insert_iterator {
+    _Container* container;
+    insert_iterator(_Container& __x) : container(&__x) {}
+};
+
+// PR4763
+template<typename T> struct s0 {};
+template<typename T> struct s0_traits {};
+template<typename T> struct s1 : s0<typename s0_traits<T>::t0> {
+  s1() {}
+};
+
+// PR6062
+namespace PR6062 {
+  template <typename T>
+  class A : public T::type
+  {
+    A() : T::type()
+    {  
+    }
+    
+    template <typename U>
+    A(U const& init)
+      : T::type(init)
+    { }
+
+    template<typename U>
+    A(U& init) : U::other_type(init) { }
+  };
+}
+
+template<typename T, typename U>
+struct X0 : T::template apply<U> {
+  X0(int i) : T::template apply<U>(i) { }
+};
+
+// PR7698
+namespace PR7698 {
+  template<typename Type>
+  class A {
+    char mA[sizeof(Type *)];
+    A(): mA() {}
+  };
+}
diff --git a/clang/test/SemaTemplate/dependent-class-member-operator.cpp b/clang/test/SemaTemplate/dependent-class-member-operator.cpp
new file mode 100644
index 0000000..d70a60c
--- /dev/null
+++ b/clang/test/SemaTemplate/dependent-class-member-operator.cpp
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// PR7837
+
+template<class T> struct C1 { void operator()(T); };
+template<class T> struct C2; // expected-note {{template is declared here}}
+template<class T> void foo(T);
+void wrap() {
+  foo(&C1<int>::operator());
+  foo(&C1<int>::operator+); // expected-error {{no member named 'operator+' in 'C1<int>'}}
+  foo(&C2<int>::operator+); // expected-error {{implicit instantiation of undefined template 'C2<int>'}}
+}
diff --git a/clang/test/SemaTemplate/dependent-expr.cpp b/clang/test/SemaTemplate/dependent-expr.cpp
new file mode 100644
index 0000000..a1ddd24
--- /dev/null
+++ b/clang/test/SemaTemplate/dependent-expr.cpp
@@ -0,0 +1,73 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// PR5908
+template <typename Iterator>
+void Test(Iterator it) {
+  *(it += 1);
+}
+
+namespace PR6045 {
+  template<unsigned int r>
+  class A
+  {
+    static const unsigned int member = r;
+    void f();
+  };
+  
+  template<unsigned int r>
+  const unsigned int A<r>::member;
+  
+  template<unsigned int r>
+  void A<r>::f() 
+  {
+    unsigned k;
+    (void)(k % member);
+  }
+}
+
+namespace PR7198 {
+  struct A
+  {
+    ~A() { }
+  };
+
+  template<typename T>
+  struct B {
+    struct C : A {};
+    void f()
+    {
+      C c = C();
+    }
+  };
+}
+
+namespace PR7724 {
+  template<typename OT> int myMethod()
+  { return 2 && sizeof(OT); }
+}
+
+namespace test4 {
+  template <typename T> T *addressof(T &v) {
+    return reinterpret_cast<T*>(
+             &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+  }
+}
+
+namespace test5 {
+  template <typename T> class chained_map {
+    int k;
+    void lookup() const {
+      int &v = (int &)k;
+    }
+  };
+}
+
+namespace PR8795 {
+  template <class _CharT> int test(_CharT t)
+  {
+    int data [] = {
+      sizeof(_CharT) > sizeof(char)
+    };
+    return data[0];
+  }
+}
diff --git a/clang/test/SemaTemplate/dependent-names-no-std.cpp b/clang/test/SemaTemplate/dependent-names-no-std.cpp
new file mode 100644
index 0000000..2fb9d99
--- /dev/null
+++ b/clang/test/SemaTemplate/dependent-names-no-std.cpp
@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+//
+// The whole point of this test is to verify certain diagnostics work in the
+// absence of namespace 'std'.
+
+namespace PR10053 {
+  namespace ns {
+    struct Data {};
+  }
+
+  template<typename T> struct A {
+    T t;
+    A() {
+      f(t); // expected-error {{call to function 'f' that is neither visible in the template definition nor found by argument-dependent lookup}}
+    }
+  };
+
+  void f(ns::Data); // expected-note {{in namespace 'PR10053::ns'}}
+
+  A<ns::Data> a; // expected-note {{in instantiation of member function}}
+}
diff --git a/clang/test/SemaTemplate/dependent-names.cpp b/clang/test/SemaTemplate/dependent-names.cpp
new file mode 100644
index 0000000..924bad9
--- /dev/null
+++ b/clang/test/SemaTemplate/dependent-names.cpp
@@ -0,0 +1,326 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 
+
+typedef double A;
+template<typename T> class B {
+  typedef int A;
+};
+
+template<typename T> struct X : B<T> {
+  static A a;
+};
+
+int a0[sizeof(X<int>::a) == sizeof(double) ? 1 : -1];
+
+// PR4365.
+template<class T> class Q;
+template<class T> class R : Q<T> {T current;};
+
+
+namespace test0 {
+  template <class T> class Base {
+  public:
+    void instance_foo();
+    static void static_foo();
+    class Inner {
+    public:
+      void instance_foo();
+      static void static_foo();
+    };
+  };
+
+  template <class T> class Derived1 : Base<T> {
+  public:
+    void test0() {
+      Base<T>::static_foo();
+      Base<T>::instance_foo();
+    }
+
+    void test1() {
+      Base<T>::Inner::static_foo();
+      Base<T>::Inner::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
+    }
+
+    static void test2() {
+      Base<T>::static_foo();
+      Base<T>::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
+    }
+
+    static void test3() {
+      Base<T>::Inner::static_foo();
+      Base<T>::Inner::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
+    }
+  };
+
+  template <class T> class Derived2 : Base<T>::Inner {
+  public:
+    void test0() {
+      Base<T>::static_foo();
+      Base<T>::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
+    }
+
+    void test1() {
+      Base<T>::Inner::static_foo();
+      Base<T>::Inner::instance_foo();
+    }
+
+    static void test2() {
+      Base<T>::static_foo();
+      Base<T>::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
+    }
+
+    static void test3() {
+      Base<T>::Inner::static_foo();
+      Base<T>::Inner::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
+    }
+  };
+
+  void test0() {
+    Derived1<int> d1;
+    d1.test0();
+    d1.test1(); // expected-note {{in instantiation of member function}}
+    d1.test2(); // expected-note {{in instantiation of member function}}
+    d1.test3(); // expected-note {{in instantiation of member function}}
+
+    Derived2<int> d2;
+    d2.test0(); // expected-note {{in instantiation of member function}}
+    d2.test1();
+    d2.test2(); // expected-note {{in instantiation of member function}}
+    d2.test3(); // expected-note {{in instantiation of member function}}
+  }
+}
+
+namespace test1 {
+  template <class T> struct Base {
+    void foo(T); // expected-note {{must qualify identifier to find this declaration in dependent base class}}
+  };
+
+  template <class T> struct Derived : Base<T> {
+    void doFoo(T v) {
+      foo(v); // expected-error {{use of undeclared identifier}}
+    }
+  };
+
+  template struct Derived<int>; // expected-note {{requested here}}
+}
+
+namespace PR8966 {
+  template <class T>
+  class MyClassCore
+  {
+  };
+
+  template <class T>
+  class MyClass : public MyClassCore<T>
+  {
+  public:
+    enum  {
+      N
+    };
+
+    // static member declaration
+    static const char* array [N];
+
+    void f() {
+      MyClass<T>::InBase = 17;
+    }
+  };
+
+  // static member definition
+  template <class T>
+  const char* MyClass<T>::array [MyClass<T>::N] = { "A", "B", "C" };
+}
+
+namespace std {
+  inline namespace v1 {
+    template<typename T> struct basic_ostream;
+  }
+  namespace inner {
+    template<typename T> struct vector {};
+  }
+  using inner::vector;
+  template<typename T, typename U> struct pair {};
+  typedef basic_ostream<char> ostream;
+  extern ostream cout;
+  std::ostream &operator<<(std::ostream &out, const char *);
+}
+
+namespace PR10053 {
+  template<typename T> struct A {
+    T t;
+    A() {
+      f(t); // expected-error {{call to function 'f' that is neither visible in the template definition nor found by argument-dependent lookup}}
+    }
+  };
+
+  void f(int&); // expected-note {{'f' should be declared prior to the call site}}
+
+  A<int> a; // expected-note {{in instantiation of member function}}
+
+
+  namespace N {
+    namespace M {
+      template<typename T> int g(T t) {
+        f(t); // expected-error {{call to function 'f' that is neither visible in the template definition nor found by argument-dependent lookup}}
+      };
+    }
+
+    void f(char&); // expected-note {{'f' should be declared prior to the call site}}
+  }
+
+  void f(char&);
+
+  int k = N::M::g<char>(0);; // expected-note {{in instantiation of function}}
+
+
+  namespace O {
+    void f(char&); // expected-note {{candidate function not viable}}
+
+    template<typename T> struct C {
+      static const int n = f(T()); // expected-error {{no matching function}}
+    };
+  }
+
+  int f(double); // no note, shadowed by O::f
+  O::C<double> c; // expected-note {{requested here}}
+
+
+  // Example from www/compatibility.html
+  namespace my_file {
+    template <typename T> T Squared(T x) {
+      return Multiply(x, x); // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}}
+    }
+
+    int Multiply(int x, int y) { // expected-note {{should be declared prior to the call site}}
+      return x * y;
+    }
+
+    int main() {
+      Squared(5); // expected-note {{here}}
+    }
+  }
+
+  // Example from www/compatibility.html
+  namespace my_file2 {
+    template<typename T>
+    void Dump(const T& value) {
+      std::cout << value << "\n"; // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}}
+    }
+
+    namespace ns {
+      struct Data {};
+    }
+
+    std::ostream& operator<<(std::ostream& out, ns::Data data) { // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2::ns'}}
+      return out << "Some data";
+    }
+
+    void Use() {
+      Dump(ns::Data()); // expected-note {{here}}
+    }
+  }
+
+  namespace my_file2_a {
+    template<typename T>
+    void Dump(const T &value) {
+      print(std::cout, value); // expected-error 4{{neither visible in the template definition nor found by argument-dependent lookup}}
+    }
+
+    namespace ns {
+      struct Data {};
+    }
+    namespace ns2 {
+      struct Data {};
+    }
+
+    std::ostream &print(std::ostream &out, int); // expected-note-re {{should be declared prior to the call site$}}
+    std::ostream &print(std::ostream &out, ns::Data); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2_a::ns'}}
+    std::ostream &print(std::ostream &out, std::vector<ns2::Data>); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2_a::ns2'}}
+    std::ostream &print(std::ostream &out, std::pair<ns::Data, ns2::Data>); // expected-note {{should be declared prior to the call site or in an associated namespace of one of its arguments}}
+
+    void Use() {
+      Dump(0); // expected-note {{requested here}}
+      Dump(ns::Data()); // expected-note {{requested here}}
+      Dump(std::vector<ns2::Data>()); // expected-note {{requested here}}
+      Dump(std::pair<ns::Data, ns2::Data>()); // expected-note {{requested here}}
+    }
+  }
+
+  namespace unary {
+    template<typename T>
+    T Negate(const T& value) {
+      return !value; // expected-error {{call to function 'operator!' that is neither visible in the template definition nor found by argument-dependent lookup}}
+    }
+
+    namespace ns {
+      struct Data {};
+    }
+
+    ns::Data operator!(ns::Data); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::unary::ns'}}
+
+    void Use() {
+      Negate(ns::Data()); // expected-note {{requested here}}
+    }
+  }
+}
+
+namespace PR10187 {
+  namespace A {
+    template<typename T>
+    struct S {
+      void f() {
+        for (auto &a : e)
+          __range(a); // expected-error {{undeclared identifier '__range'}}
+      }
+      int e[10];
+    };
+    void g() {
+      S<int>().f(); // expected-note {{here}}
+    }
+  }
+
+  namespace B {
+    template<typename T> void g(); // expected-note {{not viable}}
+    template<typename T> void f() {
+      g<int>(T()); // expected-error {{no matching function}}
+    }
+
+    namespace {
+      struct S {};
+    }
+    void g(S);
+
+    template void f<S>(); // expected-note {{here}}
+  }
+}
+
+namespace rdar11242625 {
+
+template <typename T>
+struct Main {
+  struct default_names {
+    typedef int id;
+  };
+
+  template <typename T2 = typename default_names::id>
+  struct TS {
+    T2 q;
+  };
+};
+
+struct Sub : public Main<int> {
+  TS<> ff;
+};
+
+int arr[sizeof(Sub)];
+
+}
+
+namespace PR11421 {
+template < unsigned > struct X {
+  static const unsigned dimension = 3;
+  template<unsigned dim=dimension> 
+  struct Y: Y<dim> { }; // expected-error {{incomplete type}} expected-note {{is not complete until the closing}}
+};
+typedef X<3> X3;
+X3::Y<>::iterator it; // expected-note {{requested here}}
+}
diff --git a/clang/test/SemaTemplate/dependent-sized_array.cpp b/clang/test/SemaTemplate/dependent-sized_array.cpp
new file mode 100644
index 0000000..cf0e0f3
--- /dev/null
+++ b/clang/test/SemaTemplate/dependent-sized_array.cpp
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s
+
+template<int N>
+void f() {
+  int a[] = { 1, 2, 3, N };
+  unsigned numAs = sizeof(a) / sizeof(int);
+}
+
+template void f<17>();
+
+
+template<int N>
+void f1() {
+  int a0[] = {}; // expected-warning{{zero}}
+  int a1[] = { 1, 2, 3, N };
+  int a3[sizeof(a1)/sizeof(int) != 4? 1 : -1]; // expected-error{{negative}}
+}
diff --git a/clang/test/SemaTemplate/dependent-template-recover.cpp b/clang/test/SemaTemplate/dependent-template-recover.cpp
new file mode 100644
index 0000000..3c01f65
--- /dev/null
+++ b/clang/test/SemaTemplate/dependent-template-recover.cpp
@@ -0,0 +1,60 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T, typename U, int N>
+struct X {
+  void f(T* t) {
+    t->f0<U>(); // expected-error{{use 'template' keyword to treat 'f0' as a dependent template name}}
+    t->f0<int>(); // expected-error{{use 'template' keyword to treat 'f0' as a dependent template name}}
+
+    t->operator+<U const, 1>(); // expected-error{{use 'template' keyword to treat 'operator +' as a dependent template name}}
+    t->f1<int const, 2>(); // expected-error{{use 'template' keyword to treat 'f1' as a dependent template name}}
+
+    T::getAs<U>(); // expected-error{{use 'template' keyword to treat 'getAs' as a dependent template name}}
+    t->T::getAs<U>(); // expected-error{{use 'template' keyword to treat 'getAs' as a dependent template name}}
+
+    // FIXME: We can't recover from these yet
+    (*t).f2<N>(); // expected-error{{expected expression}}
+    (*t).f2<0>(); // expected-error{{expected expression}}
+  }
+};
+
+namespace PR9401 {
+  // From GCC PR c++/45558
+  template <typename S, typename T>
+  struct C
+  {
+    template <typename U>
+    struct B
+    {
+      template <typename W>
+      struct E
+      {
+        explicit E(const W &x) : w(x) {}
+        const W &w;
+      };
+    };
+  };
+
+  struct F;
+  template <typename X>
+  struct D
+  {
+    D() {}
+  };
+
+  const D<F> g;
+  template <typename S, typename T>
+  struct A
+  {
+    template <typename U>
+    struct B : C<S, T>::template B<U>
+    {
+      typedef typename C<S, T>::template B<U> V;
+      static const D<typename V::template E<D<F> > > a;
+    };
+  };
+
+  template <typename S, typename T>
+  template <typename U>
+  const D<typename C<S, T>::template B<U>::template E<D<F> > >
+  A<S, T>::B<U>::a = typename C<S, T>::template B<U>::template E<D<F> >(g);
+}
diff --git a/clang/test/SemaTemplate/dependent-type-identity.cpp b/clang/test/SemaTemplate/dependent-type-identity.cpp
new file mode 100644
index 0000000..731013c
--- /dev/null
+++ b/clang/test/SemaTemplate/dependent-type-identity.cpp
@@ -0,0 +1,100 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// This test concerns the identity of dependent types within the
+// canonical type system. This corresponds to C++ [temp.type], which
+// specifies type equivalence within a template.
+//
+// FIXME: template template parameters
+
+namespace N {
+  template<typename T>
+  struct X2 {
+    template<typename U>
+    struct apply {
+      typedef U* type;
+    };
+  };
+}
+
+namespace Nalias = N;
+
+template<typename T>
+struct X0 { };
+
+using namespace N;
+
+template<typename T, typename U>
+struct X1 {
+  typedef T type;
+  typedef U U_type;
+
+  void f0(T); // expected-note{{previous}}
+  void f0(U);
+  void f0(type); // expected-error{{redeclar}}
+
+  void f1(T*); // expected-note{{previous}}
+  void f1(U*);
+  void f1(type*); // expected-error{{redeclar}}
+
+  void f2(X0<T>*); // expected-note{{previous}}
+  void f2(X0<U>*);
+  void f2(X0<type>*); // expected-error{{redeclar}}
+
+  void f3(X0<T>*); // expected-note{{previous}}
+  void f3(X0<U>*);
+  void f3(::X0<type>*); // expected-error{{redeclar}}  
+
+  void f4(typename T::template apply<U>*); // expected-note{{previous}}
+  void f4(typename U::template apply<U>*);
+  void f4(typename type::template apply<T>*);
+  void f4(typename type::template apply<U_type>*); // expected-error{{redeclar}}
+
+  void f5(typename T::template apply<U>::type*); // expected-note{{previous}}
+  void f5(typename U::template apply<U>::type*);
+  void f5(typename U::template apply<T>::type*);
+  void f5(typename type::template apply<T>::type*);
+  void f5(typename type::template apply<U_type>::type*); // expected-error{{redeclar}}
+
+  void f6(typename N::X2<T>::template apply<U> *); // expected-note{{previous}}
+  void f6(typename N::X2<U>::template apply<U> *);
+  void f6(typename N::X2<U>::template apply<T> *);
+  void f6(typename ::N::X2<type>::template apply<U_type> *); // expected-error{{redeclar}}
+  
+  void f7(typename N::X2<T>::template apply<U> *); // expected-note{{previous}}
+  void f7(typename N::X2<U>::template apply<U> *);
+  void f7(typename N::X2<U>::template apply<T> *);
+  void f7(typename X2<type>::template apply<U_type> *); // expected-error{{redeclar}}
+
+  void f8(typename N::X2<T>::template apply<U> *); // expected-note{{previous}}
+  void f8(typename N::X2<U>::template apply<U> *);
+  void f8(typename N::X2<U>::template apply<T> *);
+  void f8(typename ::Nalias::X2<type>::template apply<U_type> *); // expected-error{{redeclar}}
+};
+
+namespace PR6851 {
+  template <bool v>
+  struct S;
+
+  struct N {
+    template <bool w>
+    S< S<w>::cond && 1 > foo();
+  };
+
+  struct Alien;
+  bool operator&&(const Alien&, const Alien&);
+
+  template <bool w>
+  S< S<w>::cond && 1 > N::foo() { }
+}
+
+namespace PR7460 {
+  template <typename T>
+  struct TemplateClass2
+  {
+    enum { SIZE = 100 };
+    static T member[SIZE];
+  };
+
+  template <typename T>
+  T TemplateClass2<T>::member[TemplateClass2<T>::SIZE];
+}
diff --git a/clang/test/SemaTemplate/destructor-template.cpp b/clang/test/SemaTemplate/destructor-template.cpp
new file mode 100644
index 0000000..07beda4
--- /dev/null
+++ b/clang/test/SemaTemplate/destructor-template.cpp
@@ -0,0 +1,59 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename A> class s0 {
+
+  template<typename B> class s1 : public s0<A> {
+    ~s1() {}
+    s0<A> ms0;
+  };
+
+};
+
+struct Incomplete;
+
+template<typename T>
+void destroy_me(T me) {
+  me.~T();
+}
+
+template void destroy_me(Incomplete*);
+
+namespace PR6152 {
+  template<typename T> struct X { void f(); };
+  template<typename T> struct Y { };
+  template<typename T>
+  void X<T>::f() {
+    Y<T> *y;
+    y->template Y<T>::~Y();
+    y->template Y<T>::~Y<T>();
+    y->~Y();
+  }
+  
+  template struct X<int>;
+}
+
+namespace cvquals {
+  template<typename T>
+  void f(int *ptr) {
+    ptr->~T();
+  }
+
+  template void f<const volatile int>(int *);
+}
+
+namespace PR7239 {
+  template<class E> class A { };
+  class B {
+    void f() {
+      A<int>* x;
+      x->A<int>::~A<int>();
+    }
+  };
+}
+
+namespace PR7904 {
+  struct Foo {
+    template <int i> ~Foo() {} // expected-error{{destructor cannot be declared as a template}}
+  };
+  Foo f;
+}
diff --git a/clang/test/SemaTemplate/elaborated-type-specifier.cpp b/clang/test/SemaTemplate/elaborated-type-specifier.cpp
new file mode 100644
index 0000000..514c5f2
--- /dev/null
+++ b/clang/test/SemaTemplate/elaborated-type-specifier.cpp
@@ -0,0 +1,40 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+namespace PR6915 {
+  template <typename T>
+  class D {
+    enum T::X v; // expected-error{{use of 'X' with tag type that does not match previous declaration}} \
+    // expected-error{{no enum named 'X' in 'PR6915::D3'}}
+  };
+
+  struct D1 {
+    enum X { value };
+  };
+  struct D2 { 
+    class X { }; // expected-note{{previous use is here}}
+  };
+  struct D3 { };
+
+  template class D<D1>;
+  template class D<D2>; // expected-note{{in instantiation of}}
+  template class D<D3>; // expected-note{{in instantiation of}}
+}
+
+template<typename T>
+struct DeclOrDef {
+  enum T::foo; // expected-error{{nested name specifier for a declaration cannot depend on a template parameter}}
+  enum T::bar { // expected-error{{nested name specifier for a declaration cannot depend on a template parameter}}
+    value 
+  };
+};
+
+namespace PR6649 {
+  template <typename T> struct foo { 
+    class T::bar;  // expected-error{{nested name specifier for a declaration cannot depend on a template parameter}}
+    class T::bar { int x; }; // expected-error{{nested name specifier for a declaration cannot depend on a template parameter}}
+  };
+}
+
+namespace rdar8568507 {
+  template <class T> struct A *makeA(T t);
+}
diff --git a/clang/test/SemaTemplate/enum-argument.cpp b/clang/test/SemaTemplate/enum-argument.cpp
new file mode 100644
index 0000000..7d23757
--- /dev/null
+++ b/clang/test/SemaTemplate/enum-argument.cpp
@@ -0,0 +1,36 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+enum Enum { val = 1 };
+template <Enum v> struct C {
+  typedef C<v> Self;
+};
+template struct C<val>;
+
+template<typename T>
+struct get_size {
+  static const unsigned value = sizeof(T);
+};
+
+template<typename T>
+struct X0 {
+  enum {
+    Val1 = get_size<T>::value,
+    Val2,
+    SumOfValues = Val1 + Val2
+  };
+};
+
+X0<int> x0i;
+
+namespace rdar8020920 {
+  template<typename T>
+  struct X {
+    enum { e0 = 32 };
+
+    unsigned long long bitfield : e0;
+
+    void f(int j) {
+      bitfield + j;
+    }
+  };
+}
diff --git a/clang/test/SemaTemplate/enum-forward.cpp b/clang/test/SemaTemplate/enum-forward.cpp
new file mode 100644
index 0000000..b25c21f
--- /dev/null
+++ b/clang/test/SemaTemplate/enum-forward.cpp
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -fsyntax-only -fms-compatibility %s
+
+template<typename T>
+struct X {
+  enum E *e;
+};
+
+X<int> xi;
diff --git a/clang/test/SemaTemplate/example-dynarray.cpp b/clang/test/SemaTemplate/example-dynarray.cpp
new file mode 100644
index 0000000..999521e
--- /dev/null
+++ b/clang/test/SemaTemplate/example-dynarray.cpp
@@ -0,0 +1,177 @@
+// RUN: %clangxx -emit-llvm -c -o - %s
+#include <stddef.h>
+#include <stdlib.h>
+#include <assert.h>
+
+// Placement new requires <new> to be included, but we don't support that yet.
+void* operator new(size_t, void* ptr) throw() {
+  return ptr;
+}
+void operator delete(void*, void*) throw() {
+}
+
+template<typename T>
+class dynarray {
+public:
+  dynarray() { Start = Last = End = 0; }
+
+  dynarray(const dynarray &other) {
+    Start = (T*)malloc(sizeof(T) * other.size());
+    Last = End = Start + other.size();
+
+    for (unsigned I = 0, N = other.size(); I != N; ++I)
+      new (Start + I) T(other[I]);
+  }
+  
+  ~dynarray() {
+    for (unsigned I = 0, N = size(); I != N; ++I)
+      Start[I].~T();
+    
+    free(Start);
+  }
+
+  dynarray &operator=(const dynarray &other) {
+    T* NewStart = (T*)malloc(sizeof(T) * other.size());
+
+    for (unsigned I = 0, N = other.size(); I != N; ++I)
+      new (NewStart + I) T(other[I]);
+
+    for (unsigned I = 0, N = size(); I != N; ++I)
+      Start[I].~T();
+    
+    free(Start);
+    Start = NewStart;
+    Last = End = NewStart + other.size();
+    return *this;
+  }
+
+  unsigned size() const { return Last - Start; }
+  unsigned capacity() const { return End - Start; }
+
+  void push_back(const T& value);
+  
+  void pop_back() {
+    --Last;
+    Last->~T();
+  }
+
+  T& operator[](unsigned Idx) {
+    return Start[Idx];
+  }
+
+  const T& operator[](unsigned Idx) const {
+    return Start[Idx];
+  }
+
+  typedef T* iterator;
+  typedef const T* const_iterator;
+
+  iterator begin() { return Start; }
+  const_iterator begin() const { return Start; }
+  
+  iterator end() { return Last; }
+  const_iterator end() const { return Last; }
+  
+  bool operator==(const dynarray &other) const {
+    if (size() != other.size())
+      return false;
+    
+    for (unsigned I = 0, N = size(); I != N; ++I)
+      if ((*this)[I] != other[I])
+        return false;
+    
+    return true;
+  }
+  
+  bool operator!=(const dynarray &other) const {
+    return !(*this == other);
+  }
+  
+public:
+  T* Start, *Last, *End;
+};
+
+template<typename T>
+void dynarray<T>::push_back(const T& value) {
+  if (Last == End) {
+    unsigned NewCapacity = capacity() * 2;
+    if (NewCapacity == 0)
+      NewCapacity = 4;
+    
+    T* NewStart = (T*)malloc(sizeof(T) * NewCapacity);
+    
+    unsigned Size = size();
+    for (unsigned I = 0; I != Size; ++I)
+      new (NewStart + I) T(Start[I]);
+    
+    for (unsigned I = 0, N = size(); I != N; ++I)
+      Start[I].~T();
+    free(Start);
+    
+    Start = NewStart;
+    Last = Start + Size;
+    End = Start + NewCapacity;
+  }
+  
+  new (Last) T(value);
+  ++Last;
+}
+
+struct Point { 
+  Point() { x = y = z = 0.0; }
+  Point(const Point& other) : x(other.x), y(other.y), z(other.z) { }
+
+  float x, y, z;
+};
+
+int main() {
+  dynarray<int> di;
+  di.push_back(0);
+  di.push_back(1);
+  di.push_back(2);
+  di.push_back(3);
+  di.push_back(4);
+  assert(di.size() == 5);
+  for (dynarray<int>::iterator I = di.begin(), IEnd = di.end(); I != IEnd; ++I)
+    assert(*I == I - di.begin());
+
+  for (int I = 0, N = di.size(); I != N; ++I)
+    assert(di[I] == I);
+
+  di.pop_back();
+  assert(di.size() == 4);
+  di.push_back(4);
+
+  dynarray<int> di2 = di;
+  assert(di2.size() == 5);
+  assert(di.begin() != di2.begin());
+  for (dynarray<int>::iterator I = di2.begin(), IEnd = di2.end(); 
+       I != IEnd; ++I)
+    assert(*I == I - di2.begin());
+
+  dynarray<int> di3(di);
+  assert(di3.size() == 5);
+  assert(di.begin() != di3.begin());
+  for (dynarray<int>::iterator I = di3.begin(), IEnd = di3.end(); 
+       I != IEnd; ++I)
+    assert(*I == I - di3.begin());
+
+  dynarray<int> di4;
+  assert(di4.size() == 0);
+  di4 = di;
+  assert(di4.size() == 5);
+  assert(di.begin() != di4.begin());
+  for (dynarray<int>::iterator I = di4.begin(), IEnd = di4.end(); 
+       I != IEnd; ++I)
+    assert(*I == I - di4.begin());
+
+  assert(di4 == di);
+  di4[3] = 17;
+  assert(di4 != di);
+  
+  dynarray<Point> dp;
+  dp.push_back(Point());
+  assert(dp.size() == 1);
+  
+  return 0;
+}
diff --git a/clang/test/SemaTemplate/example-typelist.cpp b/clang/test/SemaTemplate/example-typelist.cpp
new file mode 100644
index 0000000..082aeb8
--- /dev/null
+++ b/clang/test/SemaTemplate/example-typelist.cpp
@@ -0,0 +1,98 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// A simple cons-style typelist
+struct nil { };
+
+template<typename Head, typename Tail = nil>
+struct cons { 
+  typedef Head head;
+  typedef Tail tail;
+};
+
+// is_same trait, for testing
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+// metaprogram that computes the length of a list
+template<typename T> struct length;
+
+template<typename Head, typename Tail>
+struct length<cons<Head, Tail> > {
+  static const unsigned value = length<Tail>::value + 1;
+};
+
+template<>
+struct length<nil> {
+  static const unsigned value = 0;
+};
+
+typedef cons<unsigned char, 
+             cons<unsigned short, 
+                  cons<unsigned int,
+                       cons<unsigned long> > > > unsigned_inttypes;
+int length0[length<unsigned_inttypes>::value == 4? 1 : -1];
+
+// metaprogram that reverses a list
+
+// FIXME: I would prefer that this be a partial specialization, but
+// that requires partial ordering of class template partial
+// specializations.
+template<typename T> 
+class reverse {
+  typedef typename reverse<typename T::tail>::type reversed_tail;
+
+  typedef typename reverse<typename reversed_tail::tail>::type most_of_tail;
+
+public:
+  typedef cons<typename reversed_tail::head,
+               typename reverse<cons<typename T::head, most_of_tail> >::type> type;
+};
+
+template<typename Head>
+class reverse<cons<Head> > {
+public:
+  typedef cons<Head> type;
+};
+
+template<>
+class reverse<nil> {
+public:
+  typedef nil type;
+};
+
+int reverse0[is_same<reverse<unsigned_inttypes>::type,
+                     cons<unsigned long, 
+                          cons<unsigned int, 
+                               cons<unsigned short,
+                                    cons<unsigned char> > > > >::value? 1 : -1];
+
+// metaprogram that finds a type within a list
+
+// FIXME: I would prefer that this be a partial specialization, but
+// that requires partial ordering of class template partial
+// specializations.
+template<typename List, typename T>
+struct find : find<typename List::tail, T> { };
+
+template<typename Tail, typename T>
+struct find<cons<T, Tail>, T> {
+  typedef cons<T, Tail> type;
+};
+
+template<typename T>
+struct find<nil, T> {
+  typedef nil type;
+};
+
+int find0[is_same<find<unsigned_inttypes, unsigned int>::type,
+                       cons<unsigned int, cons<unsigned long> > >::value?
+             1 : -1];
+int find1[is_same<find<unsigned_inttypes, int>::type, nil>::value? 1 : -1];
+
diff --git a/clang/test/SemaTemplate/explicit-instantiation.cpp b/clang/test/SemaTemplate/explicit-instantiation.cpp
new file mode 100644
index 0000000..13d76be
--- /dev/null
+++ b/clang/test/SemaTemplate/explicit-instantiation.cpp
@@ -0,0 +1,107 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template void *; // expected-error{{expected unqualified-id}}
+
+template typedef void f0; // expected-error{{explicit instantiation of typedef}}
+
+int v0; // expected-note{{refers here}}
+template int v0; // expected-error{{does not refer}}
+
+template<typename T>
+struct X0 {
+  static T value;
+  
+  T f0(T x) {
+    return x + 1;  // expected-error{{invalid operands}}
+  } 
+  T* f0(T*, T*) { return T(); }
+  
+  template<typename U>
+  T f0(T, U) { return T(); }
+};
+
+template<typename T>
+T X0<T>::value; // expected-error{{no matching constructor}}
+
+template int X0<int>::value;
+
+struct NotDefaultConstructible { // expected-note{{candidate constructor (the implicit copy constructor)}}
+  NotDefaultConstructible(int); // expected-note{{candidate constructor}}
+};
+
+template NotDefaultConstructible X0<NotDefaultConstructible>::value; // expected-note{{instantiation}}
+
+template int X0<int>::f0(int);
+template int* X0<int>::f0(int*, int*);
+template int X0<int>::f0(int, float);
+
+template int X0<int>::f0(int) const; // expected-error{{does not refer}}
+template int* X0<int>::f0(int*, float*); // expected-error{{does not refer}}
+
+struct X1 { };
+typedef int X1::*MemPtr;
+
+template MemPtr X0<MemPtr>::f0(MemPtr); // expected-note{{requested here}}
+
+struct X2 {
+  int f0(int); // expected-note{{refers here}}
+  
+  template<typename T> T f1(T) { return T(); }
+  template<typename T> T* f1(T*) { return 0; }
+
+  template<typename T, typename U> void f2(T, U*) { } // expected-note{{candidate}}
+  template<typename T, typename U> void f2(T*, U) { } // expected-note{{candidate}}
+};
+
+template int X2::f0(int); // expected-error{{not an instantiation}}
+
+template int *X2::f1(int *); // okay
+
+template void X2::f2(int *, int *); // expected-error{{ambiguous}}
+
+
+template<typename T> void print_type() { }
+
+template void print_type<int>();
+template void print_type<float>();
+
+template<typename T> void print_type(T*) { }
+
+template void print_type(int*);
+template void print_type<int>(float*); // expected-error{{does not refer}}
+
+void print_type(double*);
+template void print_type<double>(double*);
+
+// PR5069
+template<int I> void foo0 (int (&)[I + 1]) { }
+template void foo0<2> (int (&)[3]);
+
+namespace explicit_instantiation_after_implicit_instantiation {
+  template <int I> struct X0 { static int x; };
+  template <int I> int X0<I>::x;
+  void test1() { (void)&X0<1>::x; }
+  template struct X0<1>;
+}
+
+template<typename> struct X3 { };
+inline template struct X3<int>; // expected-warning{{ignoring 'inline' keyword on explicit template instantiation}}
+static template struct X3<float>; // expected-warning{{ignoring 'static' keyword on explicit template instantiation}}
+
+namespace PR7622 {
+  template<typename,typename=int>
+  struct basic_streambuf;
+
+  template<typename,typename>
+  struct basic_streambuf{friend bob<>()}; // expected-error{{unknown type name 'bob'}} \
+  // expected-error{{expected member name or ';' after declaration specifiers}}
+  template struct basic_streambuf<int>;
+}
+
+// Test that we do not crash.
+class TC1 {
+  class TC2 {
+    template // FIXME: error here.
+    void foo() { }
+   };
+};
diff --git a/clang/test/SemaTemplate/explicit-specialization-member.cpp b/clang/test/SemaTemplate/explicit-specialization-member.cpp
new file mode 100644
index 0000000..7fe6bf3
--- /dev/null
+++ b/clang/test/SemaTemplate/explicit-specialization-member.cpp
@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T>
+struct X0 {
+  typedef T* type;
+  
+  void f0(T);
+  void f1(type);
+};
+
+template<> void X0<char>::f0(char);
+template<> void X0<char>::f1(type);
+
+namespace PR6161 {
+  template<typename _CharT>
+  class numpunct : public locale::facet // expected-error{{use of undeclared identifier 'locale'}} \
+              // expected-error{{expected class name}}
+  {
+    static locale::id id; // expected-error{{use of undeclared identifier}}
+  };
+  numpunct<char>::~numpunct(); // expected-error{{expected the class name after '~' to name a destructor}}
+}
diff --git a/clang/test/SemaTemplate/ext-vector-type.cpp b/clang/test/SemaTemplate/ext-vector-type.cpp
new file mode 100644
index 0000000..f968c13
--- /dev/null
+++ b/clang/test/SemaTemplate/ext-vector-type.cpp
@@ -0,0 +1,94 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T, unsigned Length> 
+struct make1 { 
+  typedef T __attribute__((ext_vector_type(Length))) type; 
+};
+
+void test_make1() {
+  make1<int, 5>::type x;
+  x.x = 4;
+}
+
+template<typename T, unsigned Length> 
+struct make2 { 
+  typedef T __attribute__((ext_vector_type(Length))) type; // expected-error{{zero vector size}}
+};
+
+int test_make2() {
+  make2<int, 0> x; // expected-note{{in instantiation of}} 
+}
+
+template<typename T, unsigned Length> 
+struct make3 { 
+  typedef T __attribute__((ext_vector_type(Length))) type; // expected-error{{invalid vector element type 's'}}
+};
+
+struct s {};
+
+int test_make3() {
+  make3<s, 3>x; // expected-note{{in instantiation of}} 
+}
+
+template<typename T, T Length> 
+struct make4 { 
+  typedef T __attribute__((ext_vector_type(Length))) type; 
+};
+
+int test_make4() {
+  make4<int, 4>::type x;
+  x.w = 7;
+}
+
+typedef int* int_ptr;
+template<unsigned Length>
+struct make5 {
+  typedef int_ptr __attribute__((ext_vector_type(Length))) type; // expected-error{{invalid vector element type}}
+};
+
+template<int Length>
+struct make6 {
+  typedef int __attribute__((ext_vector_type(Length))) type;
+};
+
+int test_make6() {
+  make6<4>::type x;
+  x.w = 7;
+
+  make6<2>::type y;
+  y.x = -1;
+  y.w = -1; // expected-error{{vector component access exceeds type}}
+}
+
+namespace Deduction {
+  template<typename T> struct X0;
+
+  template<typename T, unsigned N>
+  struct X0<T __attribute__((ext_vector_type(N)))> {
+    static const unsigned value = 0;
+  };
+
+  template<typename T>
+  struct X0<T __attribute__((ext_vector_type(4)))> {
+    static const unsigned value = 1;
+  };
+
+  template<unsigned N>
+  struct X0<float __attribute__((ext_vector_type(N)))> {
+    static const unsigned value = 2;
+  };
+
+  template<>
+  struct X0<float __attribute__((ext_vector_type(4)))> {
+    static const unsigned value = 3;
+  };
+
+  typedef int __attribute__((ext_vector_type(2))) int2;
+  typedef int __attribute__((ext_vector_type(4))) int4;
+  typedef float __attribute__((ext_vector_type(2))) float2;
+  typedef float __attribute__((ext_vector_type(4))) float4;
+
+  int array0[X0<int2>::value == 0? 1 : -1];
+  int array1[X0<int4>::value == 1? 1 : -1];
+  int array2[X0<float2>::value == 2? 1 : -1];
+  int array3[X0<float4>::value == 3? 1 : -1];
+}
diff --git a/clang/test/SemaTemplate/extern-templates.cpp b/clang/test/SemaTemplate/extern-templates.cpp
new file mode 100644
index 0000000..eca64ed
--- /dev/null
+++ b/clang/test/SemaTemplate/extern-templates.cpp
@@ -0,0 +1,64 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T>
+class X0 {
+public:
+  void f(T t);
+  
+  struct Inner {
+    void g(T t);
+  };
+};
+
+template<typename T>
+void X0<T>::f(T t) {
+  t = 17; // expected-error{{incompatible}}
+}
+
+extern template class X0<int>;
+
+extern template class X0<int*>;
+
+template<typename T>
+void X0<T>::Inner::g(T t) {
+  t = 17; // expected-error{{incompatible}}
+}
+
+void test_intptr(X0<int*> xi, X0<int*>::Inner xii) {
+  xi.f(0);
+  xii.g(0);
+}
+
+extern template class X0<long*>; 
+
+void test_longptr(X0<long*> xl, X0<long*>::Inner xli) {
+  xl.f(0);
+  xli.g(0);
+}
+
+template class X0<long*>; // expected-note 2{{instantiation}}
+
+template<typename T>
+class X1 {
+public:
+  void f(T t) { t += 2; }
+  
+  void g(T t);
+};
+
+template<typename T>
+void X1<T>::g(T t) { 
+  t += 2; 
+}
+
+extern template class X1<void*>;
+
+void g_X1(X1<void*> x1, void *ptr) {
+  x1.g(ptr);
+}
+
+extern template void X1<const void*>::g(const void*);
+
+void g_X1_2(X1<const void *> x1, const void *ptr) {
+  x1.g(ptr);
+}
diff --git a/clang/test/SemaTemplate/fibonacci.cpp b/clang/test/SemaTemplate/fibonacci.cpp
new file mode 100644
index 0000000..ff1711f
--- /dev/null
+++ b/clang/test/SemaTemplate/fibonacci.cpp
@@ -0,0 +1,66 @@
+// RUN: %clang_cc1 -fsyntax-only %s
+
+template<unsigned I>
+struct FibonacciEval;
+
+template<unsigned I>
+struct Fibonacci {
+  enum { value = FibonacciEval<I-1>::value + FibonacciEval<I-2>::value };
+};
+
+template<unsigned I>
+struct FibonacciEval {
+  enum { value = Fibonacci<I>::value };
+};
+
+template<> struct Fibonacci<0> {
+  enum { value = 0 };
+};
+
+template<> struct Fibonacci<1> {
+  enum { value = 1 };
+};
+
+int array5[Fibonacci<5>::value == 5? 1 : -1];
+int array10[Fibonacci<10>::value == 55? 1 : -1];
+
+template<unsigned I>
+struct FibonacciEval2;
+
+template<unsigned I>
+struct Fibonacci2 {
+  static const unsigned value 
+    = FibonacciEval2<I-1>::value + FibonacciEval2<I-2>::value;
+};
+
+template<unsigned I>
+struct FibonacciEval2 {
+  static const unsigned value = Fibonacci2<I>::value;
+};
+
+template<> struct Fibonacci2<0> {
+  static const unsigned value = 0;
+};
+
+template<> struct Fibonacci2<1> {
+  static const unsigned value = 1;
+};
+
+int array5_2[Fibonacci2<5>::value == 5? 1 : -1];
+int array10_2[Fibonacci2<10>::value == 55? 1 : -1];
+
+template<unsigned I>
+struct Fibonacci3 {
+  static const unsigned value = Fibonacci3<I-1>::value + Fibonacci3<I-2>::value;
+};
+
+template<> struct Fibonacci3<0> {
+  static const unsigned value = 0;
+};
+
+template<> struct Fibonacci3<1> {
+  static const unsigned value = 1;
+};
+
+int array5_3[Fibonacci3<5>::value == 5? 1 : -1];
+int array10_3[Fibonacci3<10>::value == 55? 1 : -1];
diff --git a/clang/test/SemaTemplate/friend-template.cpp b/clang/test/SemaTemplate/friend-template.cpp
new file mode 100644
index 0000000..9c95fa0
--- /dev/null
+++ b/clang/test/SemaTemplate/friend-template.cpp
@@ -0,0 +1,245 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// PR5057
+namespace test0 {
+  namespace std {
+    class X {
+    public:
+      template<typename T> friend struct Y;
+    };
+  }
+
+  namespace std {
+    template<typename T> struct Y {};
+  }
+}
+
+namespace test1 {
+  template<typename T> void f1(T) { } // expected-note{{here}}
+
+  class X {
+    template<typename T> friend void f0(T);
+    template<typename T> friend void f1(T);
+  };
+
+  template<typename T> void f0(T) { }
+  template<typename T> void f1(T) { } // expected-error{{redefinition}}
+}
+
+// PR4768
+namespace test2 {
+  template<typename T> struct X0 {
+    template<typename U> friend struct X0;
+  };
+  
+  template<typename T> struct X0<T*> {
+    template<typename U> friend struct X0;
+  };
+
+  template<> struct X0<int> {
+    template<typename U> friend struct X0;
+  };
+
+  template<typename T> struct X1 {
+    template<typename U> friend void f2(U);
+    template<typename U> friend void f3(U);
+  };
+
+  template<typename U> void f2(U);
+
+  X1<int> x1i;
+  X0<int*> x0ip;
+
+  template<> void f2(int);
+
+  // FIXME: Should this declaration of f3 be required for the specialization of
+  // f3<int> (further below) to work? GCC and EDG don't require it, we do...
+  template<typename U> void f3(U);
+
+  template<> void f3(int);
+}
+
+// PR5332
+namespace test3 {
+  template <typename T> class Foo {
+    template <typename U>
+    friend class Foo;
+  };
+
+  Foo<int> foo;
+
+  template<typename T, T Value> struct X2a;
+
+  template<typename T, int Size> struct X2b;
+
+  template<typename T>
+  class X3 {
+    template<typename U, U Value> friend struct X2a;
+
+    // FIXME: the redeclaration note ends up here because redeclaration
+    // lookup ends up finding the friend target from X3<int>.
+    template<typename U, T Value> friend struct X2b; // expected-error {{template non-type parameter has a different type 'long' in template redeclaration}} \
+      // expected-note {{previous non-type template parameter with type 'int' is here}}
+  };
+
+  X3<int> x3i; // okay
+
+  X3<long> x3l; // expected-note {{in instantiation}}
+}
+
+// PR5716
+namespace test4 {
+  template<typename> struct A {
+    template<typename T> friend void f(const A<T>&);
+  };
+
+  template<typename T> void f(const A<T>&) {
+    int a[sizeof(T) ? -1 : -1]; // expected-error {{array with a negative size}}
+  }
+
+  void f() {
+    f(A<int>()); // expected-note {{in instantiation of function template specialization}}
+  }
+}
+
+namespace test5 {
+  class outer {
+    class foo;
+    template <typename T> friend struct cache;
+  };
+  class outer::foo {
+    template <typename T> friend struct cache;
+  };
+}
+
+// PR6022
+namespace PR6022 {
+  template <class T1, class T2 , class T3  > class A;
+
+  namespace inner {
+    template<class T1, class T2, class T3, class T> 
+    A<T1, T2, T3>& f0(A<T1, T2, T3>&, T);
+  } 
+
+  template<class T1, class T2, class T3>
+  class A {
+    template<class U1, class U2, class U3, class T>  
+    friend A<U1, U2, U3>& inner::f0(A<U1, U2, U3>&, T);
+  };
+}
+
+namespace FriendTemplateDefinition {
+  template<unsigned > struct int_c { };
+
+  template<typename T>
+  struct X {
+    template<unsigned N>
+    friend void f(X, int_c<N>) {
+      int value = N;
+    };
+  };
+
+  void test_X(X<int> x, int_c<5> i5) {
+    f(x, i5);
+  }
+}
+
+namespace PR7013a {
+  template<class > struct X0
+  {
+    typedef int type;
+  };
+  template<typename > struct X1
+  {
+  };
+  template<typename , typename T> struct X2
+  {
+    typename T::type e;
+  };
+  namespace N
+  {
+    template <typename = int, typename = X1<int> > struct X3
+    {
+      template <typename T1, typename T2, typename B> friend void op(X2<T1, T2>& , B);
+    };
+    template <typename Ch, typename Tr, typename B> void op(X2<Ch, Tr>& , B)
+    {
+      X2<int, Tr> s;
+    }
+  }
+  int n()
+  {
+    X2<int, X0<int> > ngs;
+    N::X3<> b;
+    op(ngs, b);
+    return 0;
+  }
+}
+
+namespace PR7013b {
+  template<class > struct X0
+  {
+    typedef int type;
+  };
+  template<typename > struct X1
+  {
+  };
+  template<typename , typename T> struct X2
+  {
+    typename T::type e;
+  };
+  namespace N
+  {
+    template <typename = X1<int> > struct X3
+    {
+      template <typename T1, typename T2, typename B> friend void op(X2<T1, T2>& , B);
+    };
+    template <typename Ch, typename Tr, typename B> void op(X2<Ch, Tr>& , B)
+    {
+      X2<int, Tr> s;
+    }
+  }
+  int n()
+  {
+    X2<int, X0<int> > ngs;
+    N::X3<> b;
+    op(ngs, b);
+    return 0;
+  }
+
+}
+
+namespace PR8649 {
+  template<typename T, typename U, unsigned N>
+  struct X {
+    template<unsigned M> friend class X<T, U, M>; // expected-error{{partial specialization cannot be declared as a friend}}
+  };
+
+  X<int, float, 7> x;
+}
+
+// Don't crash, and error on invalid friend type template.
+namespace friend_type_template_no_tag {
+  template <typename T> struct S {
+    template <typename U> friend S<U>; // expected-error{{friend type templates must use an elaborated type}}
+  };
+  template struct S<int>;
+}
+
+namespace PR10660 {
+  struct A {
+    template <> friend class B; // expected-error{{extraneous 'template<>' in declaration of class 'B'}}
+  };
+}
+
+namespace rdar11147355 {
+  template <class T> 
+  struct A {
+    template <class U> class B;
+    template <class S> template <class U> friend class A<S>::B; 
+  };
+  
+  template <class S> template <class U> class A<S>::B {
+  }; 
+  
+  A<double>::B<double>  ab;
+}
diff --git a/clang/test/SemaTemplate/friend.cpp b/clang/test/SemaTemplate/friend.cpp
new file mode 100644
index 0000000..e78a067
--- /dev/null
+++ b/clang/test/SemaTemplate/friend.cpp
@@ -0,0 +1,33 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T> struct A {
+  struct B { };
+  
+  friend struct B;
+};
+
+void f() {
+  A<int>::B b;
+}
+
+struct C0 {
+  friend struct A<int>;
+};
+
+namespace PR6770 {
+  namespace N {
+    int f1(int);
+  }
+  using namespace N;
+
+  namespace M { 
+    float f1(float);
+  }
+  using M::f1;
+
+  template<typename T> void f1(T, T);
+  template <class T>
+  void f() {
+    friend class f; // expected-error{{'friend' used outside of class}}
+    friend class f1; // expected-error{{'friend' used outside of class}}
+  }
+}
diff --git a/clang/test/SemaTemplate/fun-template-def.cpp b/clang/test/SemaTemplate/fun-template-def.cpp
new file mode 100644
index 0000000..0427781
--- /dev/null
+++ b/clang/test/SemaTemplate/fun-template-def.cpp
@@ -0,0 +1,48 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Tests that dependent expressions are always allowed, whereas non-dependent
+// are checked as usual.
+
+#include <stddef.h>
+
+// Fake typeid, lacking a typeinfo header.
+namespace std { class type_info {}; }
+
+struct dummy {}; // expected-note 3 {{candidate constructor (the implicit copy constructor)}}
+
+template<typename T>
+int f0(T x) {
+  return (sizeof(x) == sizeof(int))? 0 : (sizeof(x) == sizeof(double))? 1 : 2;
+}
+
+template <typename T, typename U>
+T f1(T t1, U u1, int i1)
+{
+  T t2 = i1;
+  t2 = i1 + u1;
+  ++u1;
+  u1++;
+  int i2 = u1;
+
+  i1 = t1[u1];
+  i1 *= t1;
+
+  i1(u1, t1); // error
+  u1(i1, t1);
+
+  U u2 = (T)i1;
+  static_cast<void>(static_cast<U>(reinterpret_cast<T>(
+    dynamic_cast<U>(const_cast<T>(i1)))));
+
+  new U(i1, t1);
+  new int(t1, u1);
+  new (t1, u1) int;
+  delete t1;
+
+  dummy d1 = sizeof(t1); // expected-error {{no viable conversion}}
+  dummy d2 = offsetof(T, foo); // expected-error {{no viable conversion}}
+  dummy d3 = __alignof(u1); // expected-error {{no viable conversion}}
+  i1 = typeid(t1); // expected-error {{assigning to 'int' from incompatible type 'const std::type_info'}}
+
+  return u1;
+}
diff --git a/clang/test/SemaTemplate/function-template-specialization.cpp b/clang/test/SemaTemplate/function-template-specialization.cpp
new file mode 100644
index 0000000..a0d41b2
--- /dev/null
+++ b/clang/test/SemaTemplate/function-template-specialization.cpp
@@ -0,0 +1,48 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<int N> void f0(int (&array)[N]);
+
+// Simple function template specialization (using overloading)
+template<> void f0(int (&array)[1]);
+
+void test_f0() {
+  int iarr1[1];
+  f0(iarr1);
+}
+
+// Function template specialization where there are no matches
+template<> void f0(char (&array)[1]); // expected-error{{no function template matches}}
+template<> void f0<2>(int (&array)[2]) { }
+
+// Function template specialization that requires partial ordering
+template<typename T, int N> void f1(T (&array)[N]); // expected-note{{matches}}
+template<int N> void f1(int (&array)[N]); // expected-note{{matches}}
+
+template<> void f1(float (&array)[1]);
+template<> void f1(int (&array)[1]);
+
+// Function template specialization that results in an ambiguity
+template<typename T> void f1(T (&array)[17]); // expected-note{{matches}}
+template<> void f1(int (&array)[17]); // expected-error{{ambiguous}}
+
+// Resolving that ambiguity with explicitly-specified template arguments.
+template<int N> void f2(double (&array)[N]);
+template<typename T> void f2(T (&array)[42]);
+
+template<> void f2<double>(double (&array)[42]);
+template<> void f2<42>(double (&array)[42]);
+
+void f2<25>(double (&array)[25]); // expected-error{{specialization}} 
+
+// PR5833
+namespace PR5833 {
+  template <typename T> bool f0(T &t1);
+  template <> bool f0<float>(float &t1);
+}
+template <> bool PR5833::f0<float>(float &t1) {}
+
+// PR8295
+namespace PR8295 {
+  template <typename T> void f(T t) {}
+  template <typename T> void f<T*>(T* t) {} // expected-error{{function template partial specialization is not allowed}}
+}
diff --git a/clang/test/SemaTemplate/implicit-instantiation-1.cpp b/clang/test/SemaTemplate/implicit-instantiation-1.cpp
new file mode 100644
index 0000000..d1bc5a8
--- /dev/null
+++ b/clang/test/SemaTemplate/implicit-instantiation-1.cpp
@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T, typename U>
+struct X {
+  T f(T x, U y) { return x + y; }
+
+  unsigned g(T x, U y) { return sizeof(f(x, y)); }
+};
+
+void test(X<int, int> *xii, X<int*, int> *xpi, X<int, int*> *xip) {
+  (void)xii->f(1, 2);
+  (void)xpi->f(0, 2);
+  (void)sizeof(xip->f(2, 0)); // okay: does not instantiate
+  (void)xip->g(2, 0); // okay: does not instantiate
+}
+
+template<typename T, typename U>
+T add(T t, U u) {
+  return t + u; // expected-error{{invalid operands}}
+}
+
+void test_add(char *cp, int i, int *ip) {
+  char* cp2 = add(cp, i);
+  add(cp, cp); // expected-note{{instantiation of}}
+  (void)sizeof(add(ip, ip));
+}
diff --git a/clang/test/SemaTemplate/inject-templated-friend-post.cpp b/clang/test/SemaTemplate/inject-templated-friend-post.cpp
new file mode 100644
index 0000000..39c445c
--- /dev/null
+++ b/clang/test/SemaTemplate/inject-templated-friend-post.cpp
@@ -0,0 +1,72 @@
+// RUN: %clang %s -S -emit-llvm -o - | grep -e "define linkonce_odr.*_ZlsR11std_ostreamRK8StreamerI3FooE"
+// RUN: %clang %s -S -emit-llvm -o - -DPROTOTYPE | grep -e "define linkonce_odr.*_ZlsR11std_ostreamRK8StreamerI3FooE"
+// RUN: %clang %s -S -emit-llvm -o - -DINSTANTIATE | grep -e "define linkonce_odr.*_ZlsR11std_ostreamRK8StreamerI3FooE"
+// RUN: %clang %s -S -emit-llvm -o - -DPROTOTYPE -DINSTANTIATE | grep -e "define linkonce_odr.*_ZlsR11std_ostreamRK8StreamerI3FooE"
+// RUN: %clang_cc1 %s -DREDEFINE -verify
+// RUN: %clang_cc1 %s -DPROTOTYPE -DREDEFINE -verify
+// PR8007: friend function not instantiated, reordered version.
+// Corresponds to http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38392
+
+struct std_ostream
+{
+  int dummy;
+};
+
+std_ostream cout;
+
+template <typename STRUCT_TYPE>
+struct Streamer;
+
+typedef struct Foo {} Foo;
+
+std_ostream& operator << (std_ostream&, const Streamer<Foo>&);
+
+void test(const Streamer<Foo>& foo)
+{
+    cout << foo;
+}
+
+template <typename STRUCT_TYPE>
+struct Streamer
+{
+    friend std_ostream& operator << (std_ostream& o, const Streamer& f) // expected-error{{redefinition of 'operator<<'}}
+        {
+            Streamer s(f);
+            s(o);
+            return o;
+        }
+
+    Streamer(const STRUCT_TYPE& s) : s(s) {}
+
+    const STRUCT_TYPE& s;
+    void operator () (std_ostream&) const;
+};
+
+#ifdef PROTOTYPE
+std_ostream& operator << (std_ostream&, const Streamer<Foo>&);
+#endif
+
+#ifdef INSTANTIATE
+template struct Streamer<Foo>;
+#endif
+
+#ifdef REDEFINE
+std_ostream& operator << (std_ostream& o, const Streamer<Foo>&) // expected-note{{is here}}
+{
+  return o;
+}
+#endif
+
+#ifndef INSTANTIATE
+template <>
+void Streamer<Foo>::operator () (std_ostream& o) const // expected-note{{requested here}}
+{
+}
+#endif
+
+int main(void)
+{
+    Foo foo;
+    test(foo);
+}
+
diff --git a/clang/test/SemaTemplate/inject-templated-friend.cpp b/clang/test/SemaTemplate/inject-templated-friend.cpp
new file mode 100644
index 0000000..7be613b
--- /dev/null
+++ b/clang/test/SemaTemplate/inject-templated-friend.cpp
@@ -0,0 +1,48 @@
+// RUN: %clang %s -S -emit-llvm -o - | grep -e "define linkonce_odr.*_ZlsR11std_ostreamRK8StreamerI3FooE"
+// RUN: %clang_cc1 %s -DREDEFINE -verify
+// PR8007: friend function not instantiated.
+
+struct std_ostream
+{
+  int dummy;
+};
+
+std_ostream cout;
+
+template <typename STRUCT_TYPE>
+struct Streamer
+{
+    friend std_ostream& operator << (std_ostream& o, const Streamer& f) // expected-error{{redefinition of 'operator<<'}}
+        {
+            Streamer s(f);
+            s(o);
+            return o;
+        }
+
+    Streamer(const STRUCT_TYPE& s) : s(s) {}
+
+    const STRUCT_TYPE& s;
+    void operator () (std_ostream&) const;
+};
+
+typedef struct Foo {} Foo;
+
+std_ostream& operator << (std_ostream&, const Streamer<Foo>&);
+#ifdef REDEFINE
+std_ostream& operator << (std_ostream& o, const Streamer<Foo>&) // expected-note{{is here}}
+{
+  // Sema should flag this as a redefinition
+  return o;
+}
+#endif
+
+template <>
+void Streamer<Foo>::operator () (std_ostream& o) const // expected-note{{requested here}}
+{
+}
+
+int main(void)
+{
+    Foo foo;
+    cout << foo;
+}
diff --git a/clang/test/SemaTemplate/injected-class-name.cpp b/clang/test/SemaTemplate/injected-class-name.cpp
new file mode 100644
index 0000000..4c21d25
--- /dev/null
+++ b/clang/test/SemaTemplate/injected-class-name.cpp
@@ -0,0 +1,62 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T>
+struct X {
+  X<T*> *ptr;
+};
+
+X<int> x;
+
+template<>
+struct X<int***> {
+  typedef X<int***> *ptr;
+};
+
+X<float>::X<int> xi = x; // expected-error{{qualified reference to 'X' is a constructor name rather than a template name wherever a constructor can be declared}}
+
+// [temp.local]p1:
+
+// FIXME: test template template parameters
+template<typename T, typename U>
+struct X0 {
+  typedef T type;
+  typedef U U_type;
+  typedef U_type U_type2;
+
+  void f0(const X0&); // expected-note{{here}}
+  void f0(X0&);
+  void f0(const X0<T, U>&); // expected-error{{redecl}}
+
+  void f1(const X0&); // expected-note{{here}}
+  void f1(X0&);
+  void f1(const X0<type, U_type2>&); // expected-error{{redecl}}
+
+  void f2(const X0&); // expected-note{{here}}
+  void f2(X0&);
+  void f2(const ::X0<type, U_type2>&); // expected-error{{redecl}}
+};
+
+template<typename T, T N>
+struct X1 {
+  void f0(const X1&); // expected-note{{here}}
+  void f0(X1&);
+  void f0(const X1<T, N>&); // expected-error{{redecl}}
+};
+
+namespace pr6326 {
+  template <class T> class A {
+    friend class A;
+  };
+  template class A<int>;
+}
+
+namespace ForwardDecls {
+  template<typename T>
+  struct X;
+
+  template<typename T>
+  struct X {
+    typedef T foo;
+    typedef X<T> xt;
+    typename xt::foo *t;
+  };
+}
diff --git a/clang/test/SemaTemplate/instantiate-anonymous-union.cpp b/clang/test/SemaTemplate/instantiate-anonymous-union.cpp
new file mode 100644
index 0000000..68b233a
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-anonymous-union.cpp
@@ -0,0 +1,89 @@
+// RUN: %clang_cc1 -fsyntax-only %s -Wall
+
+template <typename T> class A { struct { }; };
+
+A<int> a0;
+
+template <typename T> struct B {
+  union {
+    int a;
+    void* b;
+  };
+    
+  void f() {
+    a = 10;
+    b = 0;
+  }
+};
+
+B<int> b0;
+
+template <typename T> struct C {
+  union {
+    int a;
+    void* b;
+  };
+
+  C(int a) : a(a) { }
+  C(void* b) : b(b) { }
+};
+
+C<int> c0(0);
+
+namespace PR7088 {
+  template<typename T>
+  void f() { 
+    union { 
+      int a; 
+      union {
+        float real;
+        T d;
+      };
+    }; 
+
+    a = 17;
+    d = 3.14;
+  }
+
+  template void f<double>();
+}
+
+// Check for problems related to PR7402 that occur when template instantiation
+// instantiates implicit initializers.
+namespace PR7402 {
+  struct X {
+    union {
+      struct {
+        int x;
+        int y;
+      };
+      int v[2];
+    };
+
+    // Check that this requirement survives instantiation.
+    template <typename T> X(const T& t) : x(t), y(t) {}
+  };
+
+  X x(42.0);
+}
+
+namespace PR9188 {
+  struct X0 {
+    union {
+      int member;
+    };
+  };
+
+  static union {
+    int global;
+  };
+
+  struct X1 : X0 {
+    template<typename T>
+    int f() {
+      return this->X0::member + PR9188::global;
+    }
+  };
+
+  template int X1::f<int>();
+}
diff --git a/clang/test/SemaTemplate/instantiate-array.cpp b/clang/test/SemaTemplate/instantiate-array.cpp
new file mode 100644
index 0000000..b8229d3
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-array.cpp
@@ -0,0 +1,28 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
+
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
+#define __CONCAT(__X, __Y) __CONCAT1(__X, __Y)
+#define __CONCAT1(__X, __Y) __X ## __Y
+
+#define static_assert(__b, __m) \
+  typedef int __CONCAT(__sa, __LINE__)[__b ? 1 : -1]
+#endif
+
+template <int N> class IntArray {
+  int elems[N];
+};
+
+static_assert(sizeof(IntArray<10>) == sizeof(int) * 10, "Array size mismatch");
+static_assert(sizeof(IntArray<1>) == sizeof(int) * 1, "Array size mismatch");
+
+template <typename T> class TenElementArray {
+  int elems[10];
+};
+
+static_assert(sizeof(TenElementArray<int>) == sizeof(int) * 10, "Array size mismatch");
+
+template<typename T, int N> class Array {
+  T elems[N];
+};
+
+static_assert(sizeof(Array<int, 10>) == sizeof(int) * 10, "Array size mismatch");
diff --git a/clang/test/SemaTemplate/instantiate-attr.cpp b/clang/test/SemaTemplate/instantiate-attr.cpp
new file mode 100644
index 0000000..bbadb63
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-attr.cpp
@@ -0,0 +1,26 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template <typename T>
+struct A {
+  char a __attribute__((aligned(16)));
+
+  struct B {
+    typedef T __attribute__((aligned(16))) i16;
+    i16 x;
+  };
+};
+int a[sizeof(A<int>) == 16 ? 1 : -1];
+int a2[sizeof(A<int>::B) == 16 ? 1 : -1];
+
+// rdar://problem/8243419
+namespace test1 {
+  template <typename T> struct A {
+    int a;
+    T b[0];
+  } __attribute__((packed));
+
+  typedef A<unsigned long> type;
+
+  int test0[sizeof(type) == 4 ? 1 : -1];
+  int test1[__builtin_offsetof(type, a) == 0 ? 1 : -1];
+  int test2[__builtin_offsetof(type, b) == 4 ? 1 : -1];
+}
diff --git a/clang/test/SemaTemplate/instantiate-c99.cpp b/clang/test/SemaTemplate/instantiate-c99.cpp
new file mode 100644
index 0000000..ae15528
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-c99.cpp
@@ -0,0 +1,81 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Test template instantiation for C99-specific features.
+
+// ---------------------------------------------------------------------
+// Designated initializers
+// ---------------------------------------------------------------------
+template<typename T, typename XType, typename YType>
+struct DesigInit0 {
+  void f(XType x, YType y) {
+    T agg = { 
+      .y = y, // expected-error{{does not refer}}
+      .x = x  // expected-error{{does not refer}}
+    };
+  }
+};
+
+struct Point2D {
+  float x, y;
+};
+
+template struct DesigInit0<Point2D, int, double>;
+
+struct Point3D {
+  float x, y, z;
+};
+
+template struct DesigInit0<Point3D, int, double>;
+
+struct Color { 
+  unsigned char red, green, blue;
+};
+
+struct ColorPoint3D {
+  Color color;
+  float x, y, z;
+};
+
+template struct DesigInit0<ColorPoint3D, int, double>;
+template struct DesigInit0<Color, int, double>; // expected-note{{instantiation}}
+
+template<typename T, int Subscript1, int Subscript2,
+         typename Val1, typename Val2>
+struct DesigArrayInit0 {
+  void f(Val1 val1, Val2 val2) {
+    T array = {
+      [Subscript1] = val1,
+      [Subscript2] = val2 // expected-error{{exceeds array bounds}}
+    };
+
+    int array2[10] = { [5] = 3 };
+  }
+};
+
+template struct DesigArrayInit0<int[8], 5, 3, float, int>;
+template struct DesigArrayInit0<int[8], 5, 13, float, int>; // expected-note{{instantiation}}
+
+template<typename T, int Subscript1, int Subscript2,
+         typename Val1>
+struct DesigArrayRangeInit0 {
+  void f(Val1 val1) {
+    T array = {
+      [Subscript1...Subscript2] = val1 // expected-error{{exceeds}}
+    };
+  }
+};
+
+template struct DesigArrayRangeInit0<int[8], 3, 5, float>;
+template struct DesigArrayRangeInit0<int[8], 5, 13, float>; // expected-note{{instantiation}}
+
+// ---------------------------------------------------------------------
+// Compound literals
+// ---------------------------------------------------------------------
+template<typename T, typename Arg1, typename Arg2>
+struct CompoundLiteral0 {
+  T f(Arg1 a1, Arg2 a2) {
+    return (T){a1, a2};
+  }
+};
+
+template struct CompoundLiteral0<Point2D, int, float>;
diff --git a/clang/test/SemaTemplate/instantiate-call.cpp b/clang/test/SemaTemplate/instantiate-call.cpp
new file mode 100644
index 0000000..da1eb49
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-call.cpp
@@ -0,0 +1,51 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+namespace N1 {
+  struct X0 { };
+
+  int& f0(X0);
+}
+
+namespace N2 {
+  char& f0(char);
+
+  template<typename T, typename Result>
+  struct call_f0 {
+    void test_f0(T t) {
+      Result result = f0(t);
+    }
+  };
+}
+
+template struct N2::call_f0<int, char&>;
+template struct N2::call_f0<N1::X0, int&>;
+
+namespace N3 {
+  template<typename T, typename Result>
+  struct call_f0 {
+    void test_f0(T t) {
+      Result &result = f0(t); // expected-error {{undeclared identifier}} \
+                                 expected-error {{neither visible in the template definition nor found by argument-dependent lookup}}
+    }
+  };
+}
+
+template struct N3::call_f0<int, char&>; // expected-note{{instantiation}}
+template struct N3::call_f0<N1::X0, int&>;
+
+short& f0(char); // expected-note {{should be declared prior to the call site}}
+namespace N4 {
+  template<typename T, typename Result>
+  struct call_f0 {
+    void test_f0(T t) {
+      Result &result = f0(t);
+    }
+  };
+}
+
+template struct N4::call_f0<int, short&>;
+template struct N4::call_f0<N1::X0, int&>;
+template struct N3::call_f0<int, short&>; // expected-note{{instantiation}}
+
+// FIXME: test overloaded function call operators, calls to member
+// functions, etc.
diff --git a/clang/test/SemaTemplate/instantiate-case.cpp b/clang/test/SemaTemplate/instantiate-case.cpp
new file mode 100644
index 0000000..1cc2d5d
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-case.cpp
@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<class T>
+static int alpha(T c)
+{
+    return *c; // expected-error{{indirection requires pointer operand}}
+}
+
+template<class T>
+static void
+_shexp_match()
+{
+  switch(1) {
+  case 1:
+    alpha(1); // expected-note{{instantiation of function template}}
+  }
+}
+int main() {
+  _shexp_match<char>(); // expected-note{{instantiation of function template}}
+  return 0;
+}
diff --git a/clang/test/SemaTemplate/instantiate-cast.cpp b/clang/test/SemaTemplate/instantiate-cast.cpp
new file mode 100644
index 0000000..b3babf1
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-cast.cpp
@@ -0,0 +1,117 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+struct A { int x; }; // expected-note 2 {{candidate constructor}}
+
+class Base { 
+public:
+  virtual void f();
+};
+
+class Derived : public Base { };
+
+struct ConvertibleToInt {
+  operator int() const;
+};
+
+struct Constructible {
+  Constructible(int, float);
+};
+
+// ---------------------------------------------------------------------
+// C-style casts
+// ---------------------------------------------------------------------
+template<typename T, typename U>
+struct CStyleCast0 {
+  void f(T t) {
+    (void)((U)t); // expected-error{{cannot convert 'A' to 'int' without a conversion operator}}
+  }
+};
+
+template struct CStyleCast0<int, float>;
+template struct CStyleCast0<A, int>; // expected-note{{instantiation}}
+
+// ---------------------------------------------------------------------
+// static_cast
+// ---------------------------------------------------------------------
+template<typename T, typename U>
+struct StaticCast0 {
+  void f(T t) {
+    (void)static_cast<U>(t); // expected-error{{no matching conversion for static_cast from 'int' to 'A'}}
+  }
+};
+
+template struct StaticCast0<ConvertibleToInt, bool>;
+template struct StaticCast0<int, float>;
+template struct StaticCast0<int, A>; // expected-note{{instantiation}}
+
+// ---------------------------------------------------------------------
+// dynamic_cast
+// ---------------------------------------------------------------------
+template<typename T, typename U>
+struct DynamicCast0 {
+  void f(T t) {
+    (void)dynamic_cast<U>(t); // expected-error{{not a reference or pointer}}
+  }
+};
+
+template struct DynamicCast0<Base*, Derived*>;
+template struct DynamicCast0<Base*, A>; // expected-note{{instantiation}}
+
+// ---------------------------------------------------------------------
+// reinterpret_cast
+// ---------------------------------------------------------------------
+template<typename T, typename U>
+struct ReinterpretCast0 {
+  void f(T t) {
+    (void)reinterpret_cast<U>(t); // expected-error{{qualifiers}}
+  }
+};
+
+template struct ReinterpretCast0<void (*)(int), void (*)(float)>;
+template struct ReinterpretCast0<int const *, float *>; // expected-note{{instantiation}}
+
+// ---------------------------------------------------------------------
+// const_cast
+// ---------------------------------------------------------------------
+template<typename T, typename U>
+struct ConstCast0 {
+  void f(T t) {
+    (void)const_cast<U>(t); // expected-error{{not allowed}}
+  }
+};
+
+template struct ConstCast0<int const * *, int * *>;
+template struct ConstCast0<int const *, float *>; // expected-note{{instantiation}}
+
+// ---------------------------------------------------------------------
+// C++ functional cast
+// ---------------------------------------------------------------------
+template<typename T, typename U>
+struct FunctionalCast1 {
+  void f(T t) {
+    (void)U(t); // expected-error{{cannot convert 'A' to 'int' without a conversion operator}}
+  }
+};
+
+template struct FunctionalCast1<int, float>;
+template struct FunctionalCast1<A, int>; // expected-note{{instantiation}}
+
+// Generates temporaries, which we cannot handle yet.
+template<int N, long M>
+struct FunctionalCast2 {
+  void f() {
+    (void)Constructible(N, M);
+  }
+};
+
+template struct FunctionalCast2<1, 3>;
+
+// ---------------------------------------------------------------------
+// implicit casting
+// ---------------------------------------------------------------------
+template<typename T>
+struct Derived2 : public Base { };
+
+void test_derived_to_base(Base *&bp, Derived2<int> *dp) {
+  bp = dp;
+}
diff --git a/clang/test/SemaTemplate/instantiate-clang.cpp b/clang/test/SemaTemplate/instantiate-clang.cpp
new file mode 100644
index 0000000..34d68c4
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-clang.cpp
@@ -0,0 +1,35 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Test template instantiation for Clang-specific features.
+
+// ---------------------------------------------------------------------
+// Vector types
+// ---------------------------------------------------------------------
+typedef __attribute__(( ext_vector_type(2) )) double double2;
+typedef __attribute__(( ext_vector_type(4) )) double double4;
+
+template<typename T>
+struct ExtVectorAccess0 {
+  void f(T v1, double4 v2) {
+    v1.xy = v2.yx;
+  }
+};
+
+template struct ExtVectorAccess0<double2>;
+template struct ExtVectorAccess0<double4>;
+
+typedef __attribute__(( ext_vector_type(2) )) double double2;
+
+template<typename T, typename U, int N, int M>
+struct ShuffleVector0 {
+  void f(T t, U u, double2 a, double2 b) {
+    (void)__builtin_shufflevector(t, u, N, M); // expected-error{{index}}
+    (void)__builtin_shufflevector(a, b, N, M); // expected-error{{index}}
+    (void)__builtin_shufflevector(a, b, 2, 1);
+  }
+};
+
+template struct ShuffleVector0<double2, double2, 2, 1>;
+template struct ShuffleVector0<double2, double2, 4, 3>; // expected-note{{instantiation}}
+
+
diff --git a/clang/test/SemaTemplate/instantiate-complete.cpp b/clang/test/SemaTemplate/instantiate-complete.cpp
new file mode 100644
index 0000000..68d5ae3
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-complete.cpp
@@ -0,0 +1,146 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Tests various places where requiring a complete type involves
+// instantiation of that type.
+
+template<typename T>
+struct X {
+  X(T);
+
+  T f; // expected-error{{data member instantiated with function type 'float (int)'}} \
+       // expected-error{{data member instantiated with function type 'int (int)'}} \
+       // expected-error{{data member instantiated with function type 'char (char)'}} \
+       // expected-error{{data member instantiated with function type 'short (short)'}} \
+       // expected-error{{data member instantiated with function type 'float (float)'}}
+};
+
+X<int> f() { return 0; }
+
+struct XField {
+  X<float(int)> xf; // expected-note{{in instantiation of template class 'X<float (int)>' requested here}}
+};
+
+void test_subscript(X<double> *ptr1, X<int(int)> *ptr2, int i) {
+  (void)ptr1[i];
+  (void)ptr2[i]; // expected-note{{in instantiation of template class 'X<int (int)>' requested here}}
+}
+
+void test_arith(X<signed char> *ptr1, X<unsigned char> *ptr2,
+                X<char(char)> *ptr3, X<short(short)> *ptr4) {
+  (void)(ptr1 + 5);
+  (void)(5 + ptr2);
+  (void)(ptr3 + 5); // expected-note{{in instantiation of template class 'X<char (char)>' requested here}}
+  (void)(5 + ptr4); // expected-note{{in instantiation of template class 'X<short (short)>' requested here}}
+}
+
+void test_new() {
+  (void)new X<float>(0);
+  (void)new X<float(float)>; // expected-note{{in instantiation of template class 'X<float (float)>' requested here}}
+}
+
+void test_memptr(X<long> *p1, long X<long>::*pm1,
+                 X<long(long)> *p2, 
+                 long (X<long(long)>::*pm2)(long)) {
+  (void)(p1->*pm1);
+}
+
+// Reference binding to a base
+template<typename T>
+struct X1 { };
+
+template<typename T>
+struct X2 : public T { };
+
+void refbind_base(X2<X1<int> > &x2) {
+  X1<int> &x1 = x2;
+}
+
+// Enumerate constructors for user-defined conversion.
+template<typename T>
+struct X3 {
+  X3(T);
+};
+
+void enum_constructors(X1<float> &x1) {
+  X3<X1<float> > x3 = x1;
+}
+
+namespace PR6376 {
+  template<typename T, typename U> struct W { };
+
+  template<typename T>
+  struct X {
+    template<typename U>
+    struct apply {
+      typedef W<T, U> type;
+    };
+  };
+  
+  template<typename T, typename U>
+  struct Y : public X<T>::template apply<U>::type { };
+
+  template struct Y<int, float>;
+}
+
+namespace TemporaryObjectCopy {
+  // Make sure we instantiate classes when we create a temporary copy.
+  template<typename T>
+  struct X {
+    X(T); 
+  };
+
+  template<typename T>
+  void f(T t) {
+    const X<int> &x = X<int>(t);
+  }
+
+  template void f(int);
+}
+
+namespace PR7080 {
+  template <class T, class U>
+  class X
+  {
+    typedef char true_t;
+    class false_t { char dummy[2]; };
+    static true_t dispatch(U);
+    static false_t dispatch(...);
+    static T trigger();
+  public:
+    enum { value = sizeof(dispatch(trigger())) == sizeof(true_t) };
+  };
+
+  template <class T>
+  class rv : public T
+  { };
+
+  bool x = X<int, rv<int>&>::value;
+}
+
+namespace pr7199 {
+  template <class T> class A; // expected-note {{template is declared here}}
+  template <class T> class B {
+    class A<T>::C field; // expected-error {{implicit instantiation of undefined template 'pr7199::A<int>'}}
+  };
+
+  template class B<int>; // expected-note {{in instantiation}}
+}
+
+namespace PR8425 {
+  template <typename T>
+  class BaseT {};
+
+  template <typename T>
+  class DerivedT : public BaseT<T> {};
+
+  template <typename T>
+  class FromT {
+  public:
+    operator DerivedT<T>() const { return DerivedT<T>(); }
+  };
+
+  void test() {
+    FromT<int> ft;
+    BaseT<int> bt(ft);
+  }
+}
diff --git a/clang/test/SemaTemplate/instantiate-decl-dtor.cpp b/clang/test/SemaTemplate/instantiate-decl-dtor.cpp
new file mode 100644
index 0000000..193d976
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-decl-dtor.cpp
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 %s -fsyntax-only -verify
+
+template <typename T> struct A {
+  T x;
+  A(int y) { x = y; }
+  ~A() { *x = 10; } // expected-error {{indirection requires pointer operand}}
+};
+
+void a() {
+  A<int> b = 10; // expected-note {{requested here}}
+}
diff --git a/clang/test/SemaTemplate/instantiate-decl-init.cpp b/clang/test/SemaTemplate/instantiate-decl-init.cpp
new file mode 100644
index 0000000..6b76d72
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-decl-init.cpp
@@ -0,0 +1,46 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// PR5426 - the non-dependent obj would be fully processed and wrapped in a
+// CXXConstructExpr at definition time, which would lead to a failure at
+// instantiation time.
+struct arg {
+  arg();
+};
+
+struct oldstylemove {
+  oldstylemove(oldstylemove&);
+  oldstylemove(const arg&);
+};
+
+template <typename T>
+void fn(T t, const arg& arg) {
+  oldstylemove obj(arg);
+}
+
+void test() {
+  fn(1, arg());
+}
+
+struct X0 { };
+
+struct X1 {
+  explicit X1(const X0 &x0 = X0());
+};
+
+template<typename T>
+void f0() {
+  X1 x1;
+}
+
+template void f0<int>();
+template void f0<float>();
+
+struct NonTrivial {
+  NonTrivial();
+  ~NonTrivial();
+};
+
+template<int N> void f1() {
+  NonTrivial array[N];
+}
+template<> void f1<2>();
diff --git a/clang/test/SemaTemplate/instantiate-declref-ice.cpp b/clang/test/SemaTemplate/instantiate-declref-ice.cpp
new file mode 100644
index 0000000..49b1b63
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-declref-ice.cpp
@@ -0,0 +1,34 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<int i> struct x {
+  static const int j = i;
+  x<j>* y;
+};
+
+template<int i>
+const int x<i>::j;
+
+int array0[x<2>::j];
+
+template<typename T>
+struct X0 {
+  static const unsigned value = sizeof(T);
+};
+
+template<typename T>
+const unsigned X0<T>::value;
+
+int array1[X0<int>::value == sizeof(int)? 1 : -1];
+
+const unsigned& testX0() { return X0<int>::value; }
+
+int array2[X0<int>::value == sizeof(int)? 1 : -1];
+
+template<typename T>
+struct X1 {
+  static const unsigned value;
+};
+
+template<typename T>
+const unsigned X1<T>::value = sizeof(T);
+
+int array3[X1<int>::value == sizeof(int)? 1 : -1];
diff --git a/clang/test/SemaTemplate/instantiate-declref.cpp b/clang/test/SemaTemplate/instantiate-declref.cpp
new file mode 100644
index 0000000..7d4a2ff
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-declref.cpp
@@ -0,0 +1,117 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+namespace N {
+  struct Outer {
+    struct Inner {
+      template<typename T>
+      struct InnerTemplate {
+        struct VeryInner {
+          typedef T type;
+
+          static enum K1 { K1Val = sizeof(T) } Kind1;
+          static enum { K2Val = sizeof(T)*2 } Kind2;
+          enum { K3Val = sizeof(T)*2 } Kind3;
+
+          void foo() {
+            K1 k1 = K1Val;
+            Kind1 = K1Val;
+            Outer::Inner::InnerTemplate<type>::VeryInner::Kind2 = K2Val;
+            Kind3 = K3Val;
+          }
+
+          struct UeberInner {
+            void bar() {
+              K1 k1 = K1Val;
+              Kind1 = K1Val;
+              Outer::Inner::InnerTemplate<type>::VeryInner::Kind2 = K2Val;
+
+              InnerTemplate t;
+              InnerTemplate<type> t2;
+            }
+          };
+        };
+      };
+    };
+  };
+}
+
+typedef int INT;
+template struct N::Outer::Inner::InnerTemplate<INT>::VeryInner;
+template struct N::Outer::Inner::InnerTemplate<INT>::UeberInner; // expected-error{{no struct named 'UeberInner' in 'N::Outer::Inner::InnerTemplate<int>'}}
+
+namespace N2 {
+  struct Outer2 {
+    template<typename T, typename U = T>
+    struct Inner {
+      void foo() {
+        enum { K1Val = sizeof(T) } k1;
+        enum K2 { K2Val = sizeof(T)*2 } k2a;
+
+        K2 k2b = K2Val;
+
+        struct S { T x, y; } s1;
+        struct { U x, y; } s2;
+        s1.x = s2.x; // expected-error{{incompatible}}
+
+        typedef T type;
+        type t2 = s1.x;
+
+        typedef struct { T z; } type2;
+        type2 t3 = { s1.x };
+
+        Inner i1;
+        i1.foo();
+        Inner<T> i2;
+        i2.foo();
+      }
+    };
+  };
+}
+
+template struct N2::Outer2::Inner<float>;
+template struct N2::Outer2::Inner<int*, float*>; // expected-note{{instantiation}}
+
+// Test dependent pointer-to-member expressions.
+template<typename T>
+struct smart_ptr {
+  struct safe_bool {
+    int member;
+  };
+  
+  operator int safe_bool::*() const { 
+    return ptr? &safe_bool::member : 0;
+  }
+  
+  T* ptr;
+};
+
+void test_smart_ptr(smart_ptr<int> p) {
+  if (p) { }
+}
+
+// PR5517
+namespace test0 {
+  template <int K> struct X {
+    X() { extern void x(); }
+  };
+  void g() { X<2>(); }
+}
+
+// <rdar://problem/8302161>
+namespace test1 {
+  template <typename T> void f(T const &t) {
+    union { char c; T t_; };
+    c = 'a'; // <- this shouldn't silently fail to instantiate
+    T::foo(); // expected-error {{has no members}}
+  }
+  template void f(int const &); // expected-note {{requested here}}
+}
+
+namespace test2 {
+  template<typename T> void f() {
+    T::error; // expected-error {{no member}}
+  }
+  void g() {
+    // This counts as an odr-use, so should trigger the instantiation of f<int>.
+    (void)&f<int>; // expected-note {{here}}
+  }
+}
diff --git a/clang/test/SemaTemplate/instantiate-deeply.cpp b/clang/test/SemaTemplate/instantiate-deeply.cpp
new file mode 100644
index 0000000..c5f6594
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-deeply.cpp
@@ -0,0 +1,36 @@
+// RUN: %clang_cc1 -fsyntax-only -Wall -verify %s
+template<typename a> struct A {
+  template <typename b> struct B {
+    template <typename c> struct C {
+      template <typename d> struct D {
+        template <typename e> struct E {
+          e field;
+          E() : field(0) {
+            d v1 = 4;
+            c v2 = v1 * v1;
+            b v3 = 8;
+            a v4 = v3 * v3;
+            field += v2 + v4;
+          }
+        };
+      };
+    };
+  };
+};
+
+A<int>::B<int>::C<int>::D<int>::E<int> global;
+
+// PR5352
+template <typename T>
+class Foo {
+public:
+  Foo() {}
+  
+  struct Bar {
+    T value;
+  };
+  
+  Bar u;
+};
+
+template class Foo<int>;
diff --git a/clang/test/SemaTemplate/instantiate-default-assignment-operator.cpp b/clang/test/SemaTemplate/instantiate-default-assignment-operator.cpp
new file mode 100644
index 0000000..31cdef5
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-default-assignment-operator.cpp
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename> struct PassRefPtr { };
+template<typename T> struct RefPtr {
+  RefPtr& operator=(const RefPtr&) { int a[sizeof(T) ? -1 : -1];} // expected-error 2 {{array with a negative size}}
+  RefPtr& operator=(const PassRefPtr<T>&);
+};
+
+struct A { RefPtr<int> a; };  // expected-note {{instantiation of member function 'RefPtr<int>::operator=' requested here}}
+struct B : RefPtr<float> { }; // expected-note {{in instantiation of member function 'RefPtr<float>::operator=' requested here}}
+
+void f() {
+  A a1, a2;
+  a1 = a2;
+
+  B b1, b2;
+  b1 = b2; 
+}
diff --git a/clang/test/SemaTemplate/instantiate-dependent-nested-name.cpp b/clang/test/SemaTemplate/instantiate-dependent-nested-name.cpp
new file mode 100644
index 0000000..eb1d3fb
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-dependent-nested-name.cpp
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// PR4382
+template<typename T> struct X { static const T A = 1; };
+template<typename T, bool = X<T>::A> struct Y { typedef T A; };
+template<typename T> struct Z { typedef typename Y<T>::A A; };
+extern int x;
+extern Z<int>::A x;
diff --git a/clang/test/SemaTemplate/instantiate-elab-type-specifier.cpp b/clang/test/SemaTemplate/instantiate-elab-type-specifier.cpp
new file mode 100644
index 0000000..e5e10a8
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-elab-type-specifier.cpp
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// PR5681
+template <class T> struct Base {
+  struct foo {};
+  int foo;
+};
+
+template <class T> struct Derived : Base<T> {
+  typedef struct Base<T>::foo type;
+};
+
+template struct Derived<int>;
diff --git a/clang/test/SemaTemplate/instantiate-enum-2.cpp b/clang/test/SemaTemplate/instantiate-enum-2.cpp
new file mode 100644
index 0000000..aa3b590
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-enum-2.cpp
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 %s -fsyntax-only -verify
+
+template<int IntBits> struct X {
+  enum {
+    IntShift = (unsigned long long)IntBits,
+    ShiftedIntMask = (1 << IntShift)
+  };
+};
+X<1> x;
diff --git a/clang/test/SemaTemplate/instantiate-enum.cpp b/clang/test/SemaTemplate/instantiate-enum.cpp
new file mode 100644
index 0000000..5353a92
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-enum.cpp
@@ -0,0 +1,27 @@
+// RUN: %clang_cc1 -fsyntax-only %s
+
+template<typename T, T I, int J>
+struct adder {
+  enum {
+    value = I + J,
+    value2
+  };
+};
+
+int array1[adder<long, 3, 4>::value == 7? 1 : -1];
+
+namespace PR6375 {
+  template<typename T> 
+  void f() {
+    enum Enum
+    {
+      enumerator1 = 0xFFFFFFF,
+      enumerator2 = enumerator1 - 1
+    };
+  
+    int xb1 = enumerator1;
+    int xe1 = enumerator2;
+  }
+
+  template void f<int>();
+}
diff --git a/clang/test/SemaTemplate/instantiate-exception-spec-cxx11.cpp b/clang/test/SemaTemplate/instantiate-exception-spec-cxx11.cpp
new file mode 100644
index 0000000..8a6f9ef
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-exception-spec-cxx11.cpp
@@ -0,0 +1,133 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -ftemplate-depth 16 -fcxx-exceptions -fexceptions %s
+
+// DR1330: an exception specification for a function template is only
+// instantiated when it is needed.
+
+template<typename T> void f1(T*) throw(T); // expected-error{{incomplete type 'Incomplete' is not allowed in exception specification}}
+struct Incomplete; // expected-note{{forward}}
+
+void test_f1(Incomplete *incomplete_p, int *int_p) {
+  f1(int_p);
+  f1(incomplete_p); // expected-note{{instantiation of exception spec}}
+}
+
+template<typename T> struct A {
+  template<typename U> struct B {
+    static void f() noexcept(A<U>().n);
+  };
+
+  constexpr A() : n(true) {}
+  bool n;
+};
+
+static_assert(noexcept(A<int>::B<char>::f()), "");
+
+template<unsigned N> struct S {
+  static void recurse() noexcept(noexcept(S<N+1>::recurse())); // \
+  // expected-error {{no member named 'recurse'}} \
+  // expected-note 9{{instantiation of exception spec}}
+};
+decltype(S<0>::recurse()) *pVoid1 = 0; // ok, exception spec not needed
+decltype(&S<0>::recurse) pFn = 0; // ok, exception spec not needed
+
+template<> struct S<10> {};
+void (*pFn2)() noexcept = &S<0>::recurse; // expected-note {{instantiation of exception spec}} expected-error {{not superset}}
+
+
+template<typename T> T go(T a) noexcept(noexcept(go(a))); // \
+// expected-error 16{{call to function 'go' that is neither visible}} \
+// expected-note 16{{'go' should be declared prior to the call site}} \
+// expected-error {{recursive template instantiation exceeded maximum depth of 16}} \
+// expected-error {{use of undeclared identifier 'go'}} \
+
+void f() {
+  int k = go(0); // \
+  // expected-note {{in instantiation of exception specification for 'go<int>' requested here}}
+}
+
+
+namespace dr1330_example {
+  template <class T> struct A {
+    void f(...) throw (typename T::X); // expected-error {{'int'}}
+    void f(int);
+  };
+
+  int main() {
+    A<int>().f(42);
+  }
+
+  int test2() {
+    struct S {
+      template<typename T>
+      static int f() noexcept(noexcept(A<T>().f("boo!"))) { return 0; } // \
+      // expected-note {{instantiation of exception spec}}
+      typedef decltype(f<S>()) X;
+    };
+    S().f<S>(); // ok
+    S().f<int>(); // expected-note {{instantiation of exception spec}}
+  }
+}
+
+namespace core_19754_example {
+  template<typename T> T declval() noexcept;
+
+  template<typename T, typename = decltype(T(declval<T&&>()))>
+  struct is_movable { static const bool value = true; };
+
+  template<typename T>
+  struct wrap {
+    T val;
+    void irrelevant(wrap &p) noexcept(is_movable<T>::value);
+  };
+
+  template<typename T>
+  struct base {
+     base() {}
+     base(const typename T::type1 &);
+     base(const typename T::type2 &);
+  };
+
+  template<typename T>
+  struct type1 {
+     wrap<typename T::base> base;
+  };
+
+  template<typename T>
+  struct type2 {
+     wrap<typename T::base> base;
+  };
+
+  struct types {
+     typedef base<types> base;
+     typedef type1<types> type1;
+     typedef type2<types> type2;
+  };
+
+  base<types> val = base<types>();
+}
+
+namespace pr9485 {
+  template <typename T> void f1(T) throw(typename T::exception); // expected-note {{candidate}}
+  template <typename T> void f1(T, int = 0) throw(typename T::noitpecxe); // expected-note {{candidate}}
+
+  template <typename T> void f2(T) noexcept(T::throws); // expected-note {{candidate}}
+  template <typename T> void f2(T, int = 0) noexcept(T::sworht); // expected-note {{candidate}}
+
+  void test() {
+    f1(0); // expected-error {{ambiguous}}
+    f2(0); // expected-error {{ambiguous}}
+  }
+}
+
+struct Exc1 { char c[4]; };
+struct Exc2 { double x, y, z; };
+struct Base {
+  virtual void f() noexcept; // expected-note {{overridden}}
+};
+template<typename T> struct Derived : Base {
+  void f() noexcept (sizeof(T) == 4); // expected-error {{is more lax}}
+  void g() noexcept (T::error);
+};
+
+Derived<Exc1> d1; // ok
+Derived<Exc2> d2; // expected-note {{in instantiation of}}
diff --git a/clang/test/SemaTemplate/instantiate-exception-spec.cpp b/clang/test/SemaTemplate/instantiate-exception-spec.cpp
new file mode 100644
index 0000000..d4f12df
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-exception-spec.cpp
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// FIXME: the "note" should be down at the call site!
+template<typename T> void f1(T*) throw(T); // expected-error{{incomplete type 'Incomplete' is not allowed in exception specification}} \
+                         // expected-note{{instantiation of}}
+struct Incomplete; // expected-note{{forward}}
+
+void test_f1(Incomplete *incomplete_p, int *int_p) {
+  f1(int_p);
+  f1(incomplete_p); 
+}
diff --git a/clang/test/SemaTemplate/instantiate-expr-1.cpp b/clang/test/SemaTemplate/instantiate-expr-1.cpp
new file mode 100644
index 0000000..9395117
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-expr-1.cpp
@@ -0,0 +1,192 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<int I, int J>
+struct Bitfields {
+  int simple : I; // expected-error{{bit-field 'simple' has zero width}}
+  int parens : (J);
+};
+
+void test_Bitfields(Bitfields<0, 5> *b) {
+  (void)sizeof(Bitfields<10, 5>);
+  (void)sizeof(Bitfields<0, 1>); // expected-note{{in instantiation of template class 'Bitfields<0, 1>' requested here}}
+}
+
+template<int I, int J>
+struct BitfieldPlus {
+  int bitfield : I + J; // expected-error{{bit-field 'bitfield' has zero width}}
+};
+
+void test_BitfieldPlus() {
+  (void)sizeof(BitfieldPlus<0, 1>);
+  (void)sizeof(BitfieldPlus<-5, 5>); // expected-note{{in instantiation of template class 'BitfieldPlus<-5, 5>' requested here}}
+}
+
+template<int I, int J>
+struct BitfieldMinus {
+  int bitfield : I - J; // expected-error{{bit-field 'bitfield' has negative width (-1)}} \
+  // expected-error{{bit-field 'bitfield' has zero width}}
+};
+
+void test_BitfieldMinus() {
+  (void)sizeof(BitfieldMinus<5, 1>);
+  (void)sizeof(BitfieldMinus<0, 1>); // expected-note{{in instantiation of template class 'BitfieldMinus<0, 1>' requested here}}
+  (void)sizeof(BitfieldMinus<5, 5>); // expected-note{{in instantiation of template class 'BitfieldMinus<5, 5>' requested here}}
+}
+
+template<int I, int J>
+struct BitfieldDivide {
+  int bitfield : I / J; // expected-error{{expression is not an integral constant expression}} \
+                        // expected-note{{division by zero}}
+};
+
+void test_BitfieldDivide() {
+  (void)sizeof(BitfieldDivide<5, 1>);
+  (void)sizeof(BitfieldDivide<5, 0>); // expected-note{{in instantiation of template class 'BitfieldDivide<5, 0>' requested here}}
+}
+
+template<typename T, T I, int J>
+struct BitfieldDep {
+  int bitfield : I + J;
+};
+
+void test_BitfieldDep() {
+  (void)sizeof(BitfieldDep<int, 1, 5>);
+}
+
+template<int I>
+struct BitfieldNeg {
+  int bitfield : (-I); // expected-error{{bit-field 'bitfield' has negative width (-5)}}
+};
+
+template<typename T, T I>
+struct BitfieldNeg2 {
+  int bitfield : (-I); // expected-error{{bit-field 'bitfield' has negative width (-5)}}
+};
+
+void test_BitfieldNeg() {
+  (void)sizeof(BitfieldNeg<-5>); // okay
+  (void)sizeof(BitfieldNeg<5>); // expected-note{{in instantiation of template class 'BitfieldNeg<5>' requested here}}
+  (void)sizeof(BitfieldNeg2<int, -5>); // okay
+  (void)sizeof(BitfieldNeg2<int, 5>); // expected-note{{in instantiation of template class 'BitfieldNeg2<int, 5>' requested here}}
+}
+
+template<typename T>
+void increment(T &x) {
+  (void)++x;
+}
+
+struct Incrementable {
+  Incrementable &operator++();
+};
+
+void test_increment(Incrementable inc) {
+  increment(inc);
+}
+
+template<typename T>
+void add(const T &x) {
+  (void)(x + x);
+}
+
+namespace PR6237 {
+  template <typename T>
+  void f(T t) {
+    t++;
+  }
+
+  struct B { };
+  B operator++(B &, int);
+
+  template void f(B);
+}
+
+struct Addable {
+  Addable operator+(const Addable&) const;
+};
+
+void test_add(Addable &a) {
+  add(a);
+}
+
+struct CallOperator {
+  int &operator()(int);
+  double &operator()(double);
+};
+
+template<typename Result, typename F, typename Arg1>
+Result test_call_operator(F f, Arg1 arg1) {
+  // PR5266: non-dependent invocations of a function call operator.
+  CallOperator call_op;
+  int &ir = call_op(17);
+  return f(arg1);
+}
+
+void test_call_operator(CallOperator call_op, int i, double d) {
+  int &ir = test_call_operator<int&>(call_op, i);
+  double &dr = test_call_operator<double&>(call_op, d);
+}
+
+template<typename T>
+void test_asm(T t) {
+  asm ("nop" : "=a"(*t) : "r"(*t)); // expected-error {{indirection requires pointer operand ('int' invalid)}}
+}
+
+void test_asm() {
+  int* a;
+  test_asm(a);
+  
+  int b;
+  test_asm(b); // expected-note {{in instantiation of function template specialization 'test_asm<int>' requested here}}
+}
+
+namespace PR6424 {
+  template<int I> struct X { 
+    X() { 
+      int *ip = I; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
+    }
+  };
+  
+  template<int> struct Y {
+    typedef X<7> X7;
+    
+    void f() { X7(); } // expected-note{{instantiation}}
+  };
+  
+  template void Y<3>::f(); 
+
+  template<int I> 
+  struct X2 {
+    void *operator new(__SIZE_TYPE__) { 
+      int *ip = I; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
+      return ip;
+    }
+  };
+
+  template<int> struct Y2 {
+    typedef X2<7> X;
+    void f() { 
+      new X(); // expected-note{{instantiation of}}
+    }
+  };
+  
+  template void Y2<3>::f();
+
+  template<typename T>
+  void rdar10283928(int count) {
+    (void)new char[count]();
+  }
+
+  template void rdar10283928<int>(int);
+}
+
+namespace PR10864 {
+  template<typename T> class Vals {};
+  template<> class Vals<int> { public: static const int i = 1; };
+  template<> class Vals<float> { public: static const double i; };
+  template<typename T> void test_asm_tied(T o) {
+    __asm("addl $1, %0" : "=r" (o) : "0"(Vals<T>::i)); // expected-error {{input with type 'double' matching output with type 'float'}}
+  }
+  void test_asm_tied() {
+    test_asm_tied(1);
+    test_asm_tied(1.f); // expected-note {{instantiation of}}
+  }
+}
diff --git a/clang/test/SemaTemplate/instantiate-expr-2.cpp b/clang/test/SemaTemplate/instantiate-expr-2.cpp
new file mode 100644
index 0000000..eaa68dd
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-expr-2.cpp
@@ -0,0 +1,245 @@
+// RUN: %clang_cc1 -fsyntax-only %s
+typedef char one_byte;
+typedef char (&two_bytes)[2];
+typedef char (&four_bytes)[4];
+typedef char (&eight_bytes)[8];
+
+template<int N> struct A { };
+
+namespace N1 {
+  struct X { };
+}
+
+namespace N2 {
+  struct Y { };
+
+  two_bytes operator+(Y, Y);
+}
+
+namespace N3 {
+  struct Z { };
+
+  eight_bytes operator+(Z, Z);
+}
+
+namespace N4 {
+  one_byte operator+(N1::X, N2::Y);
+
+  template<typename T, typename U>
+  struct BinOpOverload {
+    typedef A<sizeof(T() + U())> type;
+  };
+}
+
+namespace N1 {
+  four_bytes operator+(X, X);
+}
+
+namespace N3 {
+  eight_bytes operator+(Z, Z); // redeclaration
+}
+
+void test_bin_op_overload(A<1> *a1, A<2> *a2, A<4> *a4, A<8> *a8) {
+  typedef N4::BinOpOverload<N1::X, N2::Y>::type XY;
+  XY *xy = a1;
+  typedef N4::BinOpOverload<N1::X, N1::X>::type XX;
+  XX *xx = a4;
+  typedef N4::BinOpOverload<N2::Y, N2::Y>::type YY;
+  YY *yy = a2;
+  typedef N4::BinOpOverload<N3::Z, N3::Z>::type ZZ;
+  ZZ *zz = a8;
+}
+
+namespace N3 {
+  eight_bytes operator-(::N3::Z);
+}
+
+namespace N4 {
+  template<typename T>
+  struct UnaryOpOverload {
+    typedef A<sizeof(-T())> type;
+  };
+}
+
+void test_unary_op_overload(A<8> *a8) {
+  typedef N4::UnaryOpOverload<N3::Z>::type UZ;
+  UZ *uz = a8;
+}
+
+/*
+namespace N5 {
+  template<int I>
+  struct Lookup {
+    enum { val = I, more = val + 1 };
+  };
+
+  template<bool B>
+  struct Cond {
+    enum Junk { is = B ? Lookup<B>::more : Lookup<Lookup<B+1>::more>::val };
+  };
+
+  enum { resultT = Cond<true>::is,
+         resultF = Cond<false>::is };
+}
+*/
+
+namespace N6 {
+  // non-typedependent
+  template<int I>
+  struct Lookup {};
+
+  template<bool B, typename T, typename E>
+  struct Cond {
+    typedef Lookup<B ? sizeof(T) : sizeof(E)> True;
+    typedef Lookup<!B ? sizeof(T) : sizeof(E)> False;
+  };
+
+  typedef Cond<true, int, char>::True True;
+  typedef Cond<true, int, char>::False False;
+
+  // check that we have the right types
+  Lookup<1> const &L1(False());
+  Lookup<sizeof(int)> const &L2(True());
+}
+
+
+namespace N7 {
+  // type dependent
+  template<int I>
+  struct Lookup {};
+
+  template<bool B, typename T, typename E>
+  struct Cond {
+    T foo() { return B ? T() : E(); }
+    typedef Lookup<sizeof(B ? T() : E())> Type;
+  };
+
+  //Cond<true, int*, double> C; // Errors
+  //int V(C.foo()); // Errors
+  //typedef Cond<true, int*, double>::Type Type; // Errors
+  typedef Cond<true, int, double>::Type Type;
+}
+
+template<typename T, unsigned long N> struct IntegralConstant { };
+
+template<typename T>
+struct X0 {
+  void f(T x, IntegralConstant<T, sizeof(x)>);
+};
+
+void test_X0(X0<int> x, IntegralConstant<int, sizeof(int)> ic) {
+  x.f(5,ic);
+}
+
+namespace N8 {
+  struct X {
+    X operator+(const X&) const;
+  };
+  
+  template<typename T>
+  T test_plus(const T* xp, const T& x, const T& y) {
+    x.operator+(y);
+    return xp->operator+(y);
+  }
+  
+  void test_test_plus(X x) {
+    test_plus(&x, x, x);
+  }
+}
+
+namespace N9 {
+  struct A {
+    bool operator==(int value);
+  };
+  
+  template<typename T> struct B {
+    bool f(A a) {
+      return a == 1;
+    }
+  };
+  
+  template struct B<int>;  
+}
+
+namespace N10 {
+  template <typename T>
+  class A {
+    struct X { };
+    
+  public:
+    ~A() {
+      f(reinterpret_cast<X *>(0), reinterpret_cast<X *>(0));
+    }
+    
+  private:
+    void f(X *);
+    void f(X *, X *);
+  };
+  
+  template class A<int>;
+}
+
+namespace N12 {
+  // PR5224
+  template<typename T>
+  struct A { typedef int t0; };
+  
+  struct C  {
+    C(int);
+    
+    template<typename T>
+    static C *f0(T a0) {return new C((typename A<T>::t0) 1);   }
+  };
+
+  void f0(int **a) { C::f0(a); }
+}
+
+namespace PR7202 {
+  template<typename U, typename T>
+  struct meta {
+    typedef T type;
+  };
+
+  struct X {
+    struct dummy;
+
+    template<typename T>
+    X(T, typename meta<T, dummy*>::type = 0);
+
+    template<typename T, typename A>
+    X(T, A);
+  };
+
+  template<typename T>
+  struct Z { };
+
+  template<typename T> Z<T> g(T);
+
+  struct Y {
+    template<typename T>
+    void f(T t) {
+      new X(g(*this));
+    }
+  };
+
+  template void Y::f(int);
+}
+
+namespace N13 {
+  class A{
+    A(const A&);
+
+  public:
+    ~A();
+    A(int);
+    template<typename T> A &operator<<(const T&);
+  };
+
+  template<typename T>
+  void f(T t) {
+    A(17) << t;
+  }
+
+  template void f(int);
+
+}
diff --git a/clang/test/SemaTemplate/instantiate-expr-3.cpp b/clang/test/SemaTemplate/instantiate-expr-3.cpp
new file mode 100644
index 0000000..ca88b00
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-expr-3.cpp
@@ -0,0 +1,119 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// ---------------------------------------------------------------------
+// Imaginary literals
+// ---------------------------------------------------------------------
+template<typename T>
+struct ImaginaryLiteral0 {
+  void f(T &x) {
+    x = 3.0I; // expected-error{{incompatible type}}
+  }
+};
+
+template struct ImaginaryLiteral0<_Complex float>;
+template struct ImaginaryLiteral0<int*>; // expected-note{{instantiation}}
+
+// ---------------------------------------------------------------------
+// Compound assignment operator
+// ---------------------------------------------------------------------
+namespace N1 {
+  struct X { };
+
+  int& operator+=(X&, int); // expected-note{{candidate}}
+}
+
+namespace N2 {
+  long& operator+=(N1::X&, long); // expected-note{{candidate}}
+
+  template<typename T, typename U, typename Result>
+  struct PlusEquals0 {
+    void f(T t, U u) {
+      Result r = t += u; // expected-error{{ambiguous}}
+    }
+  };
+}
+
+namespace N3 {
+  struct Y : public N1::X {
+    short& operator+=(long); // expected-note{{candidate}}
+  };
+}
+
+template struct N2::PlusEquals0<N1::X, int, int&>;
+template struct N2::PlusEquals0<N1::X, long, long&>;
+template struct N2::PlusEquals0<N3::Y, long, short&>;
+template struct N2::PlusEquals0<int, int, int&>;
+template struct N2::PlusEquals0<N3::Y, int, short&>; // expected-note{{instantiation}}
+
+// ---------------------------------------------------------------------
+// Conditional operator
+// ---------------------------------------------------------------------
+template<typename T, typename U, typename Result>
+struct Conditional0 {
+  void f(T t, U u) {
+    Result result = t? : u;
+  }
+};
+
+template struct Conditional0<int, int, int>;
+
+// ---------------------------------------------------------------------
+// Statement expressions
+// ---------------------------------------------------------------------
+template<typename T>
+struct StatementExpr0 {
+  void f(T t) {
+    (void)({
+        if (t) // expected-error{{contextually convertible}}
+          t = t + 17;
+        t + 12; // expected-error{{invalid operands}}
+      });
+  }
+};
+
+template struct StatementExpr0<int>;
+template struct StatementExpr0<N1::X>; // expected-note{{instantiation}}
+
+// ---------------------------------------------------------------------
+// __builtin_choose_expr
+// ---------------------------------------------------------------------
+template<bool Cond, typename T, typename U, typename Result>
+struct Choose0 {
+  void f(T t, U u) {
+    Result r = __builtin_choose_expr(Cond, t, u); // expected-error{{lvalue}}
+  }
+};
+
+template struct Choose0<true, int, float, int&>;
+template struct Choose0<false, int, float, float&>;
+template struct Choose0<true, int, float, float&>; // expected-note{{instantiation}}
+
+// ---------------------------------------------------------------------
+// __builtin_va_arg
+// ---------------------------------------------------------------------
+template<typename ArgType>
+struct VaArg0 {
+  void f(int n, ...) {
+    __builtin_va_list va;
+    __builtin_va_start(va, n);
+    for (int i = 0; i != n; ++i)
+      (void)__builtin_va_arg(va, ArgType);
+    __builtin_va_end(va);
+  }
+};
+
+template struct VaArg0<int>;
+
+template<typename VaList, typename ArgType>
+struct VaArg1 {
+  void f(int n, ...) {
+    VaList va;
+    __builtin_va_start(va, n); // expected-error{{int}}
+    for (int i = 0; i != n; ++i)
+      (void)__builtin_va_arg(va, ArgType); // expected-error{{int}}
+    __builtin_va_end(va); // expected-error{{int}}
+  }
+};
+
+template struct VaArg1<__builtin_va_list, int>;
+template struct VaArg1<int, int>; // expected-note{{instantiation}}
diff --git a/clang/test/SemaTemplate/instantiate-expr-4.cpp b/clang/test/SemaTemplate/instantiate-expr-4.cpp
new file mode 100644
index 0000000..d95ccfe
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-expr-4.cpp
@@ -0,0 +1,354 @@
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
+
+// ---------------------------------------------------------------------
+// C++ Functional Casts
+// ---------------------------------------------------------------------
+template<int N>
+struct ValueInit0 {
+  int f() {
+    return int();
+  }
+};
+
+template struct ValueInit0<5>;
+
+template<int N>
+struct FunctionalCast0 {
+  int f() {
+    return int(N);
+  }
+};
+
+template struct FunctionalCast0<5>;
+
+struct X { // expected-note 3 {{candidate constructor (the implicit copy constructor)}}
+  X(int, int); // expected-note 3 {{candidate constructor}}
+};
+
+template<int N, int M>
+struct BuildTemporary0 {
+  X f() {
+    return X(N, M);
+  }
+};
+
+template struct BuildTemporary0<5, 7>;
+
+template<int N, int M>
+struct Temporaries0 {
+  void f() {
+    (void)X(N, M);
+  }
+};
+
+template struct Temporaries0<5, 7>;
+
+// Ensure that both the constructor and the destructor are instantiated by
+// checking for parse errors from each.
+template<int N> struct BadX {
+  BadX() { int a[-N]; } // expected-error {{array with a negative size}}
+  ~BadX() { int a[-N]; } // expected-error {{array with a negative size}}
+};
+
+template<int N>
+struct PR6671 {
+  void f() { (void)BadX<1>(); } // expected-note 2 {{instantiation}}
+};
+template struct PR6671<1>;
+
+// ---------------------------------------------------------------------
+// new/delete expressions
+// ---------------------------------------------------------------------
+struct Y { };
+
+template<typename T>
+struct New0 {
+  T* f(bool x) {
+    if (x)
+      return new T; // expected-error{{no matching}}
+    else
+      return new T();
+  }
+};
+
+template struct New0<int>;
+template struct New0<Y>;
+template struct New0<X>; // expected-note{{instantiation}}
+
+template<typename T, typename Arg1>
+struct New1 {
+  T* f(bool x, Arg1 a1) {
+    return new T(a1); // expected-error{{no matching}}
+  }
+};
+
+template struct New1<int, float>;
+template struct New1<Y, Y>;
+template struct New1<X, Y>; // expected-note{{instantiation}}
+
+template<typename T, typename Arg1, typename Arg2>
+struct New2 {
+  T* f(bool x, Arg1 a1, Arg2 a2) {
+    return new T(a1, a2); // expected-error{{no matching}}
+  }
+};
+
+template struct New2<X, int, float>;
+template struct New2<X, int, int*>; // expected-note{{instantiation}}
+// FIXME: template struct New2<int, int, float>;
+
+// PR5833
+struct New3 {
+  New3();
+
+  void *operator new[](__SIZE_TYPE__) __attribute__((unavailable)); // expected-note{{explicitly made unavailable}}
+};
+
+template<class C>
+void* object_creator() {
+  return new C(); // expected-error{{call to unavailable function 'operator new[]'}}
+}
+
+template void *object_creator<New3[4]>(); // expected-note{{instantiation}}
+
+template<typename T>
+struct Delete0 {
+  void f(T t) {
+    delete t; // expected-error{{cannot delete}}
+    ::delete [] t; // expected-error{{cannot delete}}
+  }
+};
+
+template struct Delete0<int*>;
+template struct Delete0<X*>;
+template struct Delete0<int>; // expected-note{{instantiation}}
+
+namespace PR5755 {
+  template <class T>
+  void Foo() {
+    char* p = 0;
+    delete[] p;
+  }
+  
+  void Test() {
+    Foo<int>();
+  }
+}
+
+namespace PR10480 {
+  template<typename T>
+  struct X {
+    X();
+    ~X() {
+      T *ptr = 1; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
+    }
+  };
+
+  template<typename T>
+  void f() {
+    new X<int>[1]; // expected-note{{in instantiation of member function 'PR10480::X<int>::~X' requested here}}
+  }
+
+  template void f<int>();
+}
+
+// ---------------------------------------------------------------------
+// throw expressions
+// ---------------------------------------------------------------------
+template<typename T>
+struct Throw1 {
+  void f(T t) {
+    throw;
+    throw t; // expected-error{{incomplete type}}
+  }
+};
+
+struct Incomplete; // expected-note 2{{forward}}
+
+template struct Throw1<int>;
+template struct Throw1<int*>;
+template struct Throw1<Incomplete*>; // expected-note{{instantiation}}
+
+// ---------------------------------------------------------------------
+// typeid expressions
+// ---------------------------------------------------------------------
+
+namespace std {
+  class type_info;
+}
+
+template<typename T>
+struct TypeId0 {
+  const std::type_info &f(T* ptr) {
+    if (ptr)
+      return typeid(ptr);
+    else
+      return typeid(T); // expected-error{{'typeid' of incomplete type 'Incomplete'}}
+  }
+};
+
+struct Abstract {
+  virtual void f() = 0;
+};
+
+template struct TypeId0<int>;
+template struct TypeId0<Incomplete>; // expected-note{{instantiation of member function}}
+template struct TypeId0<Abstract>;
+
+// ---------------------------------------------------------------------
+// type traits
+// ---------------------------------------------------------------------
+template<typename T>
+struct is_pod {
+  static const bool value = __is_pod(T);
+};
+
+static int is_pod0[is_pod<X>::value? -1 : 1];
+static int is_pod1[is_pod<Y>::value? 1 : -1];
+
+// ---------------------------------------------------------------------
+// initializer lists
+// ---------------------------------------------------------------------
+template<typename T, typename Val1>
+struct InitList1 {
+  void f(Val1 val1) { 
+    T x = { val1 };
+  }
+};
+
+struct APair {
+  int *x;
+  const float *y;
+};
+
+template struct InitList1<int[1], float>;
+template struct InitList1<APair, int*>;
+
+template<typename T, typename Val1, typename Val2>
+struct InitList2 {
+  void f(Val1 val1, Val2 val2) { 
+    T x = { val1, val2 }; // expected-error{{cannot initialize}}
+  }
+};
+
+template struct InitList2<APair, int*, float*>;
+template struct InitList2<APair, int*, double*>; // expected-note{{instantiation}}
+
+// ---------------------------------------------------------------------
+// member references
+// ---------------------------------------------------------------------
+template<typename T, typename Result>
+struct DotMemRef0 {
+  void f(T t) {
+    Result result = t.m; // expected-error{{non-const lvalue reference to type}}
+  }
+};
+
+struct MemInt {
+  int m;
+};
+
+struct InheritsMemInt : MemInt { };
+
+struct MemIntFunc {
+  static int m(int);
+};
+
+template struct DotMemRef0<MemInt, int&>;
+template struct DotMemRef0<InheritsMemInt, int&>;
+template struct DotMemRef0<MemIntFunc, int (*)(int)>;
+template struct DotMemRef0<MemInt, float&>; // expected-note{{instantiation}}
+
+template<typename T, typename Result>
+struct ArrowMemRef0 {
+  void f(T t) {
+    Result result = t->m; // expected-error 2{{non-const lvalue reference}}
+  }
+};
+
+template<typename T>
+struct ArrowWrapper {
+  T operator->();
+};
+
+template struct ArrowMemRef0<MemInt*, int&>;
+template struct ArrowMemRef0<InheritsMemInt*, int&>;
+template struct ArrowMemRef0<MemIntFunc*, int (*)(int)>;
+template struct ArrowMemRef0<MemInt*, float&>; // expected-note{{instantiation}}
+
+template struct ArrowMemRef0<ArrowWrapper<MemInt*>, int&>;
+template struct ArrowMemRef0<ArrowWrapper<InheritsMemInt*>, int&>;
+template struct ArrowMemRef0<ArrowWrapper<MemIntFunc*>, int (*)(int)>;
+template struct ArrowMemRef0<ArrowWrapper<MemInt*>, float&>; // expected-note{{instantiation}}
+template struct ArrowMemRef0<ArrowWrapper<ArrowWrapper<MemInt*> >, int&>;
+
+struct UnresolvedMemRefArray {
+  int f(int);
+  int f(char);
+};
+UnresolvedMemRefArray Arr[10];
+template<typename U> int UnresolvedMemRefArrayT(U u) {
+  return Arr->f(u);
+}
+template int UnresolvedMemRefArrayT<int>(int);
+
+// FIXME: we should be able to return a MemInt without the reference!
+MemInt &createMemInt(int);
+
+template<int N>
+struct NonDepMemberExpr0 {
+  void f() {
+    createMemInt(N).m = N;
+  }
+};
+
+template struct NonDepMemberExpr0<0>; 
+
+template<typename T, typename Result>
+struct MemberFuncCall0 {
+  void f(T t) {
+    Result result = t.f();
+  }
+};
+
+template<typename T>
+struct HasMemFunc0 {
+  T f();
+};
+
+
+template struct MemberFuncCall0<HasMemFunc0<int&>, const int&>;
+
+template<typename Result>
+struct ThisMemberFuncCall0 {
+  Result g();
+
+  void f() {
+    Result r1 = g();
+    Result r2 = this->g();
+  }
+};
+
+template struct ThisMemberFuncCall0<int&>;
+
+template<typename T>
+struct NonDepMemberCall0 {
+  void foo(HasMemFunc0<int&> x) {
+    T result = x.f(); // expected-error{{non-const lvalue reference}}
+  }
+};
+
+template struct NonDepMemberCall0<int&>;
+template struct NonDepMemberCall0<const int&>;
+template struct NonDepMemberCall0<float&>; // expected-note{{instantiation}}
+
+
+template<typename T>
+struct QualifiedDeclRef0 {
+  T f() {
+    return is_pod<X>::value; // expected-error{{non-const lvalue reference to type 'int' cannot bind to a value of unrelated type 'const bool'}}
+  }
+};
+
+template struct QualifiedDeclRef0<bool>;
+template struct QualifiedDeclRef0<int&>; // expected-note{{instantiation}}
diff --git a/clang/test/SemaTemplate/instantiate-expr-5.cpp b/clang/test/SemaTemplate/instantiate-expr-5.cpp
new file mode 100644
index 0000000..13b7eae
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-expr-5.cpp
@@ -0,0 +1,38 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template <class A> int x(A x) { return x++; }
+int y() { return x<int>(1); }
+
+namespace PR5880 {
+  template<typename T>
+  struct A { 
+    static const int a  = __builtin_offsetof(T, a.array[5].m); // expected-error{{no member named 'a' in 'HasM'}}
+  };
+  struct HasM {
+    float m;
+  };
+
+  struct ArrayOfHasM {
+    HasM array[10];
+  };
+
+  struct B { ArrayOfHasM a; };
+  A<B> x;
+  A<HasM> x2; // expected-note{{in instantiation of}}
+
+  template<typename T>
+  struct AnonymousUnion {
+    union {
+      int i;
+      float f;
+    };
+  };
+
+  template<typename T>
+  void test_anon_union() {
+    int array1[__builtin_offsetof(AnonymousUnion<T>, f) == 0? 1 : -1];
+    int array2[__builtin_offsetof(AnonymousUnion<int>, f) == 0? 1 : -1];
+  }
+
+  template void test_anon_union<int>();
+}
diff --git a/clang/test/SemaTemplate/instantiate-expr-basic.cpp b/clang/test/SemaTemplate/instantiate-expr-basic.cpp
new file mode 100644
index 0000000..a266a65
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-expr-basic.cpp
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -std=c++11 %s
+
+template <typename T>
+struct S {
+  void f() {
+    __func__; // PredefinedExpr
+    10;       // IntegerLiteral
+    10.5;     // FloatingLiteral
+    'c';      // CharacterLiteral
+    "hello";  // StringLiteral
+    true;     // CXXBooleanLiteralExpr
+    nullptr;  // CXXNullPtrLiteralExpr
+    __null;   // GNUNullExpr
+  }
+};
+
+template struct S<int>;
diff --git a/clang/test/SemaTemplate/instantiate-field.cpp b/clang/test/SemaTemplate/instantiate-field.cpp
new file mode 100644
index 0000000..a148ee4
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-field.cpp
@@ -0,0 +1,104 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T>
+struct X {
+  int x;
+  T y; // expected-error{{data member instantiated with function type}}
+  T* z;
+  T bitfield : 12; // expected-error{{bit-field 'bitfield' has non-integral type 'float'}} \
+                  // expected-error{{data member instantiated with function type}}
+
+  mutable T x2; // expected-error{{data member instantiated with function type}}
+};
+
+void test1(const X<int> *xi) {
+  int i1 = xi->x;
+  const int &i2 = xi->y;
+  int* ip1 = xi->z;
+  int i3 = xi->bitfield;
+  xi->x2 = 17;
+}
+
+void test2(const X<float> *xf) {
+  (void)xf->x; // expected-note{{in instantiation of template class 'X<float>' requested here}}
+}
+
+void test3(const X<int(int)> *xf) {
+  (void)xf->x; // expected-note{{in instantiation of template class 'X<int (int)>' requested here}}
+}
+
+namespace PR7123 {
+  template <class > struct requirement_;
+
+  template <void(*)()> struct instantiate
+  { };
+
+  template <class > struct requirement ;
+  struct failed ;
+
+  template <class Model> struct requirement<failed *Model::*>
+  {
+    static void failed()
+    {
+      ((Model*)0)->~Model(); // expected-note{{in instantiation of}}
+    }
+  };
+
+  template <class Model> struct requirement_<void(*)(Model)> : requirement<failed *Model::*>
+  { };
+
+  template <int> struct Requires_
+  { typedef void type; };
+
+  template <class Model> struct usage_requirements
+  {
+    ~usage_requirements()
+    {((Model*)0)->~Model(); } // expected-note{{in instantiation of}}
+  };
+
+  template < typename TT > struct BidirectionalIterator
+  {
+    enum
+      { value = 0 };
+  
+    instantiate< requirement_<void(*)(usage_requirements<BidirectionalIterator>)>::failed> int534; // expected-note{{in instantiation of}}
+  
+    ~BidirectionalIterator()
+    { i--; } // expected-error{{cannot decrement value of type 'PR7123::X'}}
+  
+    TT i;
+  };
+
+  struct X
+  { };
+
+  template<typename RanIter> 
+  typename Requires_< BidirectionalIterator<RanIter>::value >::type sort(RanIter,RanIter){}
+
+  void f()
+  {
+    X x;
+    sort(x,x);
+  }
+}
+
+namespace PR7355 {
+  template<typename T1> class A {
+    class D; // expected-note{{declared here}}
+    D d; //expected-error{{implicit instantiation of undefined member 'PR7355::A<int>::D'}}
+  };
+
+  A<int> ai; // expected-note{{in instantiation of}}
+}
+
+namespace PR8712 {
+  template <int dim>
+  class B {
+  public:
+    B(const unsigned char i);
+    unsigned char value : (dim > 0 ? dim : 1);
+  };
+
+  template <int dim>
+  inline B<dim>::B(const unsigned char i) : value(i) {}
+}
diff --git a/clang/test/SemaTemplate/instantiate-friend-class.cpp b/clang/test/SemaTemplate/instantiate-friend-class.cpp
new file mode 100644
index 0000000..c87b8d0
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-friend-class.cpp
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// PR4794
+
+template <class T> class X
+{
+  friend class Y;
+};
+X<int> y;
+
diff --git a/clang/test/SemaTemplate/instantiate-function-1.cpp b/clang/test/SemaTemplate/instantiate-function-1.cpp
new file mode 100644
index 0000000..ceef274
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-function-1.cpp
@@ -0,0 +1,249 @@
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
+template<typename T, typename U>
+struct X0 {
+  void f(T x, U y) { 
+    (void)(x + y); // expected-error{{invalid operands}}
+  }
+};
+
+struct X1 { };
+
+template struct X0<int, float>;
+template struct X0<int*, int>;
+template struct X0<int X1::*, int>; // expected-note{{instantiation of}}
+
+template<typename T>
+struct X2 {
+  void f(T);
+
+  T g(T x, T y) {
+    /* DeclStmt */;
+    T *xp = &x, &yr = y; // expected-error{{pointer to a reference}}
+    /* NullStmt */;
+  }
+};
+
+template struct X2<int>;
+template struct X2<int&>; // expected-note{{instantiation of}}
+
+template<typename T>
+struct X3 {
+  void f(T) {
+    Label:
+    T x;
+    goto Label;
+  }
+};
+
+template struct X3<int>;
+
+template <typename T> struct X4 {
+  T f() const {
+    return; // expected-error{{non-void function 'f' should return a value}}
+  }
+  
+  T g() const {
+    return 1; // expected-error{{void function 'g' should not return a value}}
+  }
+};
+
+template struct X4<void>; // expected-note{{in instantiation of}}
+template struct X4<int>; // expected-note{{in instantiation of}}
+
+struct Incomplete; // expected-note 2{{forward declaration}}
+
+template<typename T> struct X5 {
+  T f() { } // expected-error{{incomplete result type}}
+};
+void test_X5(X5<Incomplete> x5); // okay!
+
+template struct X5<Incomplete>; // expected-note{{instantiation}}
+
+template<typename T, typename U, typename V> struct X6 {
+  U f(T t, U u, V v) {
+    // IfStmt
+    if (t > 0)
+      return u;
+    else { 
+      if (t < 0)
+        return v; // expected-error{{cannot initialize return object of type}}
+    }
+
+    if (T x = t) {
+      t = x;
+    }
+    return v; // expected-error{{cannot initialize return object of type}}
+  }
+};
+
+struct ConvertibleToInt {
+  operator int() const;
+};
+
+template struct X6<ConvertibleToInt, float, char>;
+template struct X6<bool, int, int*>; // expected-note{{instantiation}}
+
+template <typename T> struct X7 {
+  void f() {
+    void *v = this;
+  }
+};
+
+template struct X7<int>;
+
+template<typename T> struct While0 {
+  void f(T t) {
+    while (t) {
+    }
+
+    while (T t2 = T()) ;
+  }
+};
+
+template struct While0<float>;
+
+template<typename T> struct Do0 {
+  void f(T t) {
+    do {
+    } while (t); // expected-error{{not contextually}}
+  }
+};
+
+struct NotConvertibleToBool { };
+template struct Do0<ConvertibleToInt>;
+template struct Do0<NotConvertibleToBool>; // expected-note{{instantiation}}
+
+template<typename T> struct For0 {
+  void f(T f, T l) {
+    for (; f != l; ++f) {
+      if (*f)
+        continue;
+      else if (*f == 17)
+        break;
+    }
+  }
+};
+
+template struct For0<int*>;
+
+template<typename T> struct Member0 {
+  void f(T t) {
+    t;
+    t.f;
+    t->f;
+    
+    T* tp;
+    tp.f; // expected-error{{member reference base type 'T *' is not a structure or union}}
+    tp->f;
+
+    this->f;
+    this.f; // expected-error{{member reference base type 'Member0<T> *' is not a structure or union}}
+  }
+};
+
+template<typename T, typename U> struct Switch0 {
+  U f(T value, U v0, U v1, U v2) {
+    switch (value) {
+    case 0: return v0;
+
+    case 1: return v1;
+
+    case 2: // fall through
+
+    default:
+      return  v2;
+    }
+  }
+};
+
+template struct Switch0<int, float>;
+
+template<typename T, int I1, int I2> struct Switch1 {
+  T f(T x, T y, T z) {
+    switch (x) {
+    case I1: return y; // expected-note{{previous}}
+    case I2: return z; // expected-error{{duplicate}}
+    default: return x;
+    }
+  }
+};
+
+template struct Switch1<int, 1, 2>;
+template struct Switch1<int, 2, 2>; // expected-note{{instantiation}}
+
+template<typename T> struct IndirectGoto0 {
+  void f(T x) {
+    // FIXME: crummy error message below
+    goto *x; // expected-error{{incompatible}}
+
+  prior:
+    T prior_label;
+    prior_label = &&prior; // expected-error{{assigning to 'int'}}
+
+    T later_label;
+    later_label = &&later; // expected-error{{assigning to 'int'}}
+
+  later:
+    (void)(1+1);
+  }
+};
+
+template struct IndirectGoto0<void*>;
+template struct IndirectGoto0<int>; // expected-note{{instantiation}}
+
+template<typename T> struct TryCatch0 {
+  void f() {
+    try {
+    } catch (T t) { // expected-error{{incomplete type}} \
+                    // expected-error{{abstract class}}
+    } catch (...) {
+    }
+  }
+};
+
+struct Abstract {
+  virtual void foo() = 0; // expected-note{{pure virtual}}
+};
+
+template struct TryCatch0<int>; // okay
+template struct TryCatch0<Incomplete*>; // expected-note{{instantiation}}
+template struct TryCatch0<Abstract>; // expected-note{{instantiation}}
+
+// PR4383
+template<typename T> struct X;
+template<typename T> struct Y : public X<T> {
+  Y& x() { return *this; }
+};
+
+// Make sure our assertions don't get too uppity.
+namespace test0 {
+  template <class T> class A { void foo(T array[10]); };
+  template class A<int>;
+}
+
+namespace PR7016 {
+  template<typename T> void f() { T x = x; }
+  template void f<int>();
+}
+
+namespace PR9880 {
+  struct lua_State;
+  struct no_tag { char a; };			// (A)
+  struct yes_tag { long a; long b; };	// (A)
+
+  template <typename T>
+  struct HasIndexMetamethod {
+    template <typename U>
+    static no_tag check(...);
+    template <typename U>
+    static yes_tag check(char[sizeof(&U::luaIndex)]);
+    enum { value = sizeof(check<T>(0)) == sizeof(yes_tag) };
+  };
+  
+  class SomeClass {
+  public:
+    int luaIndex(lua_State* L);
+  };
+  
+  int i = HasIndexMetamethod<SomeClass>::value;
+}
diff --git a/clang/test/SemaTemplate/instantiate-function-1.mm b/clang/test/SemaTemplate/instantiate-function-1.mm
new file mode 100644
index 0000000..c67b598
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-function-1.mm
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// XFAIL: *
+
+template<typename T> struct Member0 {
+  void f(T t) {
+    t;
+    t.f;
+    t->f;
+    
+    T* tp;
+    tp.f;
+    tp->f;
+
+    this->f;
+    this.f; // expected-error{{member reference base type 'struct Member0 *const' is not a structure or union}}
+  }
+};
diff --git a/clang/test/SemaTemplate/instantiate-function-2.cpp b/clang/test/SemaTemplate/instantiate-function-2.cpp
new file mode 100644
index 0000000..19a8b61
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-function-2.cpp
@@ -0,0 +1,66 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template <typename T> struct S {
+  S() { }
+  S(T t);
+};
+
+template struct S<int>;
+
+void f() {
+  S<int> s1;
+  S<int> s2(10);
+}
+
+namespace PR7184 {
+  template<typename T>
+  void f() {
+    typedef T type;
+    void g(int array[sizeof(type)]);
+  }
+
+  template void f<int>();
+}
+
+namespace UsedAttr {
+  template<typename T>
+  void __attribute__((used)) foo() {
+    T *x = 1; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
+  }
+
+  void bar() {
+    foo<int>(); // expected-note{{instantiation of}}
+  }
+}
+
+namespace PR9654 {
+  typedef void ftype(int);
+
+  template<typename T>
+  ftype f;
+
+  void g() {
+    f<int>(0);
+  }
+}
+
+namespace AliasTagDef {
+  template<typename T>
+  T f() {
+    using S = struct { // expected-warning {{C++11}}
+      T g() {
+        return T();
+      }
+    };
+    return S().g();
+  }
+
+  int n = f<int>();
+}
+
+namespace PR10273 {
+  template<typename T> void (f)(T t) {}
+
+  void g() {
+    (f)(17);
+  }
+}
diff --git a/clang/test/SemaTemplate/instantiate-function-params.cpp b/clang/test/SemaTemplate/instantiate-function-params.cpp
new file mode 100644
index 0000000..54847e4
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-function-params.cpp
@@ -0,0 +1,90 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// PR6619
+template<bool C> struct if_c { };
+template<typename T1> struct if_ {
+  typedef if_c< static_cast<bool>(T1::value)> almost_type_; // expected-note 5{{in instantiation}}
+};
+template <class Model, void (Model::*)()> struct wrap_constraints { };
+template <class Model> 
+inline char has_constraints_(Model* ,  // expected-note 2{{while substituting deduced template arguments into function template 'has_constraints_' [with }} \
+                             // expected-note 3{{candidate template ignored}}
+                               wrap_constraints<Model,&Model::constraints>* = 0); // expected-note 2{{in instantiation}}
+
+template <class Model> struct not_satisfied {
+  static const bool value = sizeof( has_constraints_((Model*)0)  == 1); // expected-error 3{{no matching function}}
+};
+template <class ModelFn> struct requirement_;
+template <void(*)()> struct instantiate {
+};
+template <class Model> struct requirement_<void(*)(Model)>                           : if_<       not_satisfied<Model>         >::type { // expected-note 5{{in instantiation}}
+};
+template <class Model> struct usage_requirements {
+};
+template < typename TT > struct InputIterator                            {
+    typedef  instantiate< & requirement_<void(*)(usage_requirements<InputIterator> x)>::failed> boost_concept_check1; // expected-note {{in instantiation}}
+};
+template < typename TT > struct ForwardIterator                              : InputIterator<TT>                              { // expected-note {{in instantiation}}
+  typedef instantiate< & requirement_<void(*)(usage_requirements<ForwardIterator> x)>::failed> boost_concept_check2; // expected-note {{in instantiation}}
+
+};
+typedef instantiate< &requirement_<void(*)(ForwardIterator<char*> x)>::failed> boost_concept_checkX;// expected-note 3{{in instantiation}}
+
+template<typename T> struct X0 { };
+template<typename R, typename A1> struct X0<R(A1 param)> { };
+
+template<typename T, typename A1, typename A2>
+void instF0(X0<T(A1)> x0a, X0<T(A2)> x0b) {
+  X0<T(A1)> x0c;
+  X0<T(A2)> x0d;
+}
+
+template void instF0<int, int, float>(X0<int(int)>, X0<int(float)>);
+
+template<typename R, typename A1, R (*ptr)(A1)> struct FuncPtr { };
+template<typename A1, int (*ptr)(A1)> struct FuncPtr<int, A1, ptr> { };
+
+template<typename R, typename A1> R unary_func(A1);
+
+template<typename R, typename A1, typename A2>
+void use_func_ptr() {
+  FuncPtr<R, A1, &unary_func<R, A1> > fp1;
+  FuncPtr<R, A2, &unary_func<R, A2> > fp2;
+};
+
+template void use_func_ptr<int, float, double>();
+
+namespace PR6990 {
+  template < typename , typename = int, typename = int > struct X1;
+  template <typename >
+  struct X2;
+
+  template <typename = int *, typename TokenT = int,
+            typename = int( X2<TokenT> &)> 
+  struct X3
+  {
+  };
+
+  template <typename , typename P> 
+  struct X3_base : X3< X1<int, P> >
+  {
+  protected: typedef X1< P> type;
+    X3<type> e;
+  };
+
+  struct r : X3_base<int, int>
+  {
+  };
+}
+
+namespace InstantiateFunctionTypedef {
+  template<typename T>
+  struct X {
+    typedef int functype(int, int);
+    functype func;
+  };
+
+  void f(X<int> x) {
+    (void)x.func(1, 2);
+  }
+}
diff --git a/clang/test/SemaTemplate/instantiate-init.cpp b/clang/test/SemaTemplate/instantiate-init.cpp
new file mode 100644
index 0000000..f0ca9a5
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-init.cpp
@@ -0,0 +1,109 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+struct X0 { // expected-note 4{{candidate}}
+  X0(int*, float*); // expected-note 4{{candidate}}
+};
+
+template<typename T, typename U>
+X0 f0(T t, U u) {
+  X0 x0(t, u); // expected-error{{no matching}}
+  return X0(t, u); // expected-error{{no matching}}
+}
+
+void test_f0(int *ip, float *fp, double *dp) {
+  f0(ip, fp);
+  f0(ip, dp); // expected-note{{instantiation}}
+}
+
+template<typename Ret, typename T, typename U>
+Ret f1(Ret *retty, T t, U u) {
+  Ret r0(t, u); // expected-error{{no matching}}
+  return Ret(t, u); // expected-error{{no matching}}
+}
+
+void test_f1(X0 *x0, int *ip, float *fp, double *dp) {
+  f1(x0, ip, fp);
+  f1(x0, ip, dp); // expected-note{{instantiation}}
+}
+
+namespace PR6457 {
+  template <typename T> struct X { explicit X(T* p = 0) { }; };
+  template <typename T> struct Y { Y(int, const T& x); };
+  struct A { };
+  template <typename T>
+  struct B {
+    B() : y(0, X<A>()) { }
+    Y<X<A> > y;
+  };
+  B<int> b;
+}
+
+namespace PR6657 {
+  struct X
+  {
+    X (int, int) { }
+  };
+
+  template <typename>
+  void f0()
+  {
+    X x = X(0, 0);
+  }
+
+  void f1()
+  {
+    f0<int>();
+  }
+}
+
+// Instantiate out-of-line definitions of static data members which complete
+// types through an initializer even when the only use of the member that would
+// cause instantiation is in an unevaluated context, but one requiring its
+// complete type.
+namespace PR10001 {
+  template <typename T> struct S {
+    static const int arr[];
+    static const int x;
+    static int f();
+  };
+
+  template <typename T> const int S<T>::arr[] = { 1, 2, 3 };
+  template <typename T> const int S<T>::x = sizeof(arr) / sizeof(arr[0]);
+  template <typename T> int S<T>::f() { return x; }
+
+  int x = S<int>::f();
+}
+
+namespace PR7985 {
+  template<int N> struct integral_c { };
+
+  template <typename T, int N>
+  integral_c<N> array_lengthof(T (&x)[N]) { return integral_c<N>(); } // expected-note 2{{candidate template ignored: failed template argument deduction}}
+
+  template<typename T>
+  struct Data {
+    T x;
+  };
+
+  template<typename T>
+  struct Description {
+    static const Data<T> data[];
+  };
+
+  template<typename T>
+  const Data<T> Description<T>::data[] = {{ 1 }}; // expected-error{{cannot initialize a member subobject of type 'int *' with an rvalue of type 'int'}}
+
+  template<>
+  Data<float*> Description<float*>::data[];
+
+  void test() {
+    integral_c<1> ic1 = array_lengthof(Description<int>::data);
+    (void)sizeof(array_lengthof(Description<float>::data));
+
+    sizeof(array_lengthof( // expected-error{{no matching function for call to 'array_lengthof'}}
+                          Description<int*>::data // expected-note{{in instantiation of static data member 'PR7985::Description<int *>::data' requested here}}
+                          ));
+
+    array_lengthof(Description<float*>::data); // expected-error{{no matching function for call to 'array_lengthof'}}
+  }
+}
diff --git a/clang/test/SemaTemplate/instantiate-invalid.cpp b/clang/test/SemaTemplate/instantiate-invalid.cpp
new file mode 100644
index 0000000..b8a5901
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-invalid.cpp
@@ -0,0 +1,52 @@
+// RUN: not %clang_cc1 -fsyntax-only %s
+namespace PR6375 {
+  template<class Conv> class rasterizer_sl_clip Conv::xi(x2), Conv::yi(y2));
+namespace agg
+{
+	template<class Clip=rasterizer_sl_clip_int> class rasterizer_scanline_aa
+	{
+		template<class Scanline> bool sweep_scanline(Scanline& sl)
+		{
+			unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
+			while(num_cells) { }
+		}
+	}
+    class scanline_u8 {}
+    template<class PixelFormat> class renderer_base { }
+}
+    template<class Rasterizer, class Scanline, class BaseRenderer, class ColorT>
+    void render_scanlines_aa_solid(Rasterizer& ras, Scanline& sl, BaseRenderer& ren, const ColorT& color)
+    {
+            while(ras.sweep_scanline(sl))
+            {
+        }
+    };
+namespace agg
+{
+    struct rgba8
+    {
+    };
+    template<class Rasterizer, class Scanline, class Renderer, class Ctrl>
+    void render_ctrl(Rasterizer& ras, Scanline& sl, Renderer& r, Ctrl& c)
+    {
+        unsigned i;
+            render_scanlines_aa_solid(ras, sl, r, c.color(i));
+        }
+    template<class ColorT> class rbox_ctrl : public rbox_ctrl_impl
+    {
+        const ColorT& color(unsigned i) const { return *m_colors[i]; }
+    }
+class the_application : public agg::platform_support
+{
+    agg::rbox_ctrl<agg::rgba8> m_polygons;
+    virtual void on_init()
+    {
+        typedef agg::renderer_base<pixfmt_type> base_ren_type;
+        base_ren_type ren_base(pf);
+        agg::scanline_u8 sl;
+        agg::rasterizer_scanline_aa<> ras;
+        agg::render_ctrl(ras, sl, ren_base, m_polygons);
+    }
+};
+}
+}
diff --git a/clang/test/SemaTemplate/instantiate-local-class.cpp b/clang/test/SemaTemplate/instantiate-local-class.cpp
new file mode 100644
index 0000000..20b62c1
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-local-class.cpp
@@ -0,0 +1,67 @@
+// RUN: %clang_cc1 -verify %s
+template<typename T>
+void f0() {
+  struct X;
+  typedef struct Y {
+    T (X::* f1())(int) { return 0; }
+  } Y2;
+
+  Y2 y = Y();
+}
+
+template void f0<int>();
+
+// PR5764
+namespace PR5764 {
+  struct X {
+    template <typename T>
+    void Bar() {
+      typedef T ValueType;
+      struct Y {
+        Y() { V = ValueType(); }
+
+        ValueType V;
+      };
+
+      Y y;
+    }
+  };
+
+  void test(X x) {
+    x.Bar<int>();
+  }
+}
+
+// Instantiation of local classes with virtual functions.
+namespace local_class_with_virtual_functions {
+  template <typename T> struct X { };
+  template <typename T> struct Y { };
+
+  template <typename T>
+  void f() {
+    struct Z : public X<Y<T>*> {
+      virtual void g(Y<T>* y) { }
+      void g2(int x) {(void)x;}
+    };
+    Z z;
+    (void)z;
+  }
+
+  struct S { };
+  void test() { f<S>(); }
+}
+
+namespace PR8801 {
+  template<typename T>
+  void foo() {
+    class X;
+    typedef int (X::*pmf_type)();
+    class X : public T { };
+    
+    pmf_type pmf = &T::foo;
+  }
+
+  struct Y { int foo(); };
+
+  template void foo<Y>();
+}
diff --git a/clang/test/SemaTemplate/instantiate-member-class.cpp b/clang/test/SemaTemplate/instantiate-member-class.cpp
new file mode 100644
index 0000000..bb64276
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-member-class.cpp
@@ -0,0 +1,142 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+namespace PR8965 {
+  template<typename T>
+  struct X {
+    typedef int type;
+
+    T field; // expected-note{{in instantiation of member class}}
+  };
+
+  template<typename T>
+  struct Y {
+    struct Inner;
+
+    typedef typename X<Inner>::type // expected-note{{in instantiation of template class}}
+      type; // expected-note{{not-yet-instantiated member is declared here}}
+
+    struct Inner {
+      typedef type field; // expected-error{{no member 'type' in 'PR8965::Y<int>'; it has not yet been instantiated}}
+    };
+  };
+
+  Y<int> y; // expected-note{{in instantiation of template class}}
+}
+
+template<typename T>
+class X {
+public:
+  struct C { T &foo(); };
+
+  struct D {
+    struct E { T &bar(); }; // expected-error{{cannot form a reference to 'void'}}
+    struct F; // expected-note{{member is declared here}}
+  };
+};
+
+X<int>::C *c1;
+X<float>::C *c2;
+
+X<int>::X *xi; // expected-error{{qualified reference to 'X' is a constructor name rather than a type wherever a constructor can be declared}}
+X<float>::X *xf; // expected-error{{qualified reference to 'X' is a constructor name rather than a type wherever a constructor can be declared}}
+
+void test_naming() {
+  c1 = c2; // expected-error{{assigning to 'X<int>::C *' from incompatible type 'X<float>::C *'}}
+  xi = xf;  // expected-error{{assigning to 'X<int>::X<int> *' from incompatible type 'X<float>::X<float> *'}}
+    // FIXME: error above doesn't print the type X<int>::X cleanly!
+}
+
+void test_instantiation(X<double>::C *x,
+                        X<float>::D::E *e,
+                        X<float>::D::F *f) {
+  double &dr = x->foo();
+  float &fr = e->bar();
+  f->foo(); // expected-error{{implicit instantiation of undefined member 'X<float>::D::F'}}
+  
+}
+
+
+X<void>::C *c3; // okay
+X<void>::D::E *e1; // okay
+X<void>::D::E e2; // expected-note{{in instantiation of member class 'X<void>::D::E' requested here}}
+
+// Redeclarations.
+namespace test1 {
+  template <typename T> struct Registry {
+    struct node;
+    static node *Head;
+    struct node {
+      node(int v) { Head = this; }
+    };
+  };
+  void test() {
+    Registry<int>::node node(0);
+  }
+}
+
+// Redeclarations during explicit instantiations.
+namespace test2 {
+  template <typename T> class A {
+    class Foo;
+    class Foo {
+      int foo();
+    };
+  };
+  template class A<int>;
+
+  template <typename T> class B {
+    class Foo;
+    class Foo {
+    public:
+      typedef int X;
+    };
+    typename Foo::X x;
+    class Foo;
+  };
+  template class B<int>;
+
+  template <typename T> class C {
+    class Foo;
+    class Foo;
+  };
+  template <typename T> class C<T>::Foo {
+    int x;
+  };
+  template class C<int>;
+}
+
+namespace AliasTagDef {
+  template<typename T>
+  struct F {
+    using S = struct U { // expected-warning {{C++11}}
+      T g() {
+        return T();
+      }
+    };
+  };
+
+  int m = F<int>::S().g();
+  int n = F<int>::U().g();
+}
+
+namespace rdar10397846 {
+  template<int I> struct A
+  {
+    struct B
+    {
+      struct C { C() { int *ptr = I; } }; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
+    };
+  };
+
+  template<int N> void foo()
+  {
+    class A<N>::B::C X; // expected-note{{in instantiation of member function}}
+    int A<N+1>::B::C::*member = 0;
+  }
+
+  void bar()
+  {
+    foo<0>();
+    foo<1>(); // expected-note{{in instantiation of function template}}
+  }
+}
diff --git a/clang/test/SemaTemplate/instantiate-member-expr.cpp b/clang/test/SemaTemplate/instantiate-member-expr.cpp
new file mode 100644
index 0000000..a31569a
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-member-expr.cpp
@@ -0,0 +1,68 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T>
+struct S {
+ S() { }
+};
+
+template<typename T>
+struct vector {
+  void push_back(const T&) { int a[sizeof(T) ? -1: -1]; } // expected-error {{array with a negative size}}
+};
+
+class ExprEngine {
+public:
+ typedef vector<S<void *> >CheckersOrdered;
+ CheckersOrdered Checkers;
+
+ template <typename CHECKER>
+ void registerCheck(CHECKER *check) {
+   Checkers.push_back(S<void *>()); // expected-note {{in instantiation of member function 'vector<S<void *> >::push_back' requested here}}
+ }
+};
+
+class RetainReleaseChecker { };
+
+void f(ExprEngine& Eng) {
+   Eng.registerCheck(new RetainReleaseChecker); // expected-note {{in instantiation of function template specialization 'ExprEngine::registerCheck<RetainReleaseChecker>' requested here}}
+}
+
+// PR 5838
+namespace test1 {
+  template<typename T> struct A {
+    int a;
+  };
+
+  template<typename T> struct B : A<float>, A<T> {
+    void f() {
+      a = 0; // should not be ambiguous
+    }
+  };
+  template struct B<int>;
+
+  struct O {
+    int a;
+    template<typename T> struct B : A<T> {
+      void f() {
+        a = 0; // expected-error {{'test1::O::a' is not a member of class 'test1::O::B<int>'}}
+      }
+    };
+  };
+  template struct O::B<int>; // expected-note {{in instantiation}}
+}
+
+// PR7248
+namespace test2 {
+  template <class T> struct A {
+    void foo() {
+      T::bar(); // expected-error {{type 'int' cannot}}
+    }
+  };
+
+  template <class T> class B {
+    void foo(A<T> a) {
+      a.test2::template A<T>::foo(); // expected-note {{in instantiation}}
+    }
+  };
+
+  template class B<int>;
+}
diff --git a/clang/test/SemaTemplate/instantiate-member-initializers.cpp b/clang/test/SemaTemplate/instantiate-member-initializers.cpp
new file mode 100644
index 0000000..45503b3
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-member-initializers.cpp
@@ -0,0 +1,27 @@
+// RUN: %clang_cc1 -fsyntax-only -Wall -verify %s
+
+template<typename T> struct A {
+  A() : a(1) { } // expected-error{{cannot initialize a member subobject of type 'void *' with an rvalue of type 'int'}}
+
+  T a;
+};
+
+A<int> a0;
+A<void*> a1; // expected-note{{in instantiation of member function 'A<void *>::A' requested here}}
+
+template<typename T> struct B {
+  B() : b(1), // expected-warning {{field 'b' will be initialized after field 'a'}}
+    a(2) { }
+  
+  int a;
+  int b;
+};
+
+B<int> b0; // expected-note {{in instantiation of member function 'B<int>::B' requested here}}
+
+template <class T> struct AA { AA(int); };
+template <class T> class BB : public AA<T> {
+public:
+  BB() : AA<T>(1) {}
+};
+BB<int> x;
diff --git a/clang/test/SemaTemplate/instantiate-member-pointers.cpp b/clang/test/SemaTemplate/instantiate-member-pointers.cpp
new file mode 100644
index 0000000..0db90e3
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-member-pointers.cpp
@@ -0,0 +1,67 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+struct Y {
+  int x;
+};
+
+template<typename T>
+struct X1 {
+  int f(T* ptr, int T::*pm) { // expected-error{{member pointer}}
+    return ptr->*pm;
+  }
+};
+
+template struct X1<Y>;
+template struct X1<int>; // expected-note{{instantiation}}
+
+template<typename T, typename Class>
+struct X2 {
+  T f(Class &obj, T Class::*pm) { // expected-error{{to a reference}} \
+                      // expected-error{{member pointer to void}}
+    return obj.*pm; 
+  }
+};
+
+template struct X2<int, Y>;
+template struct X2<int&, Y>; // expected-note{{instantiation}}
+template struct X2<const void, Y>; // expected-note{{instantiation}}
+
+template<typename T, typename Class, T Class::*Ptr>
+struct X3 {
+  X3<T, Class, Ptr> &operator=(const T& value) {
+    return *this;
+  }
+};
+
+X3<int, Y, &Y::x> x3;
+
+typedef int Y::*IntMember;
+
+template<IntMember Member>
+struct X4 {
+  X3<int, Y, Member> member;
+  
+  int &getMember(Y& y) { return y.*Member; }
+};
+
+int &get_X4(X4<&Y::x> x4, Y& y) { 
+  return x4.getMember(y); 
+}
+
+template<IntMember Member>
+void accept_X4(X4<Member>);
+
+void test_accept_X4(X4<&Y::x> x4) {
+  accept_X4(x4);
+}
+
+namespace ValueDepMemberPointer {
+  template <void (*)()> struct instantiate_function {};
+  template <typename T> struct S {
+    static void instantiate();
+    typedef instantiate_function<&S::instantiate> x; // expected-note{{instantiation}}
+  };
+  template <typename T> void S<T>::instantiate() {
+    int a[(int)sizeof(T)-42]; // expected-error{{array with a negative size}}
+  }
+  S<int> s; 
+}
diff --git a/clang/test/SemaTemplate/instantiate-member-template.cpp b/clang/test/SemaTemplate/instantiate-member-template.cpp
new file mode 100644
index 0000000..4c74f5f
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-member-template.cpp
@@ -0,0 +1,261 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T>
+struct X0 {
+  template<typename U> T f0(U);
+  template<typename U> U& f1(T*, U); // expected-error{{pointer to a reference}} \
+                                     // expected-note{{candidate}}
+};
+
+X0<int> x0i;
+X0<void> x0v;
+X0<int&> x0ir; // expected-note{{instantiation}}
+
+void test_X0(int *ip, double *dp) {
+  X0<int> xi;
+  int i1 = xi.f0(ip);
+  double *&dpr = xi.f1(ip, dp);
+  xi.f1(dp, dp); // expected-error{{no matching}}
+
+  X0<void> xv;
+  double *&dpr2 = xv.f1(ip, dp);
+}
+
+template<typename T>
+struct X1 {
+  template<typename U>
+  struct Inner0 {
+    U x; 
+    T y; // expected-error{{void}}
+  };
+
+  template<typename U>
+  struct Inner1 {
+    U x; // expected-error{{void}}
+    T y;
+  };
+  
+  template<typename U>
+  struct Inner2 {
+    struct SuperInner {
+      U z; // expected-error{{void}}
+    };
+  };
+  
+  template<typename U>
+  struct Inner3 {
+    void f0(T t, U u) { // expected-note{{passing argument to parameter 't' here}}
+      (void)(t + u); // expected-error{{invalid operands}}
+    }
+    
+    template<typename V>
+    V f1(T t, U u, V) {
+      return t + u; // expected-error{{cannot initialize return object}}
+    }
+  };
+  
+  template<typename U>
+  struct Inner4;
+};
+
+template<typename T>
+template<typename U>
+struct X1<T>::Inner4 {
+  template<typename V>
+  V f2(T t, U u, V);
+  
+  static U value;
+};
+
+template<typename T>
+template<typename U>
+U X1<T>::Inner4<U>::value; // expected-error{{reference variable}}
+
+template<typename T>
+template<typename U>
+template<typename V>
+V X1<T>::Inner4<U>::f2(T t, U u, V) {
+  return t + u; // expected-error{{cannot initialize return object}}
+}
+
+void test_X1(int *ip, int i, double *dp) {
+  X1<void>::Inner0<int> *xvip; // okay
+  X1<void>::Inner0<int> xvi; // expected-note{{instantiation}}
+  
+  X1<int>::Inner1<void> *xivp; // okay
+  X1<int>::Inner1<void> xiv; // expected-note{{instantiation}}
+  
+  X1<int>::Inner2<void>::SuperInner *xisivp; // okay
+  X1<int>::Inner2<void>::SuperInner xisiv; // expected-note{{instantiation}}
+  
+  X1<int*>::Inner3<int> id3;
+  id3.f0(ip, i);
+  id3.f0(dp, i); // expected-error{{cannot initialize a parameter of type 'int *' with an lvalue of type 'double *'}}
+  id3.f1(ip, i, ip);
+  id3.f1(ip, i, dp); // expected-note{{instantiation}}
+  
+  X1<int*>::Inner3<double*> id3b;
+  id3b.f0(ip, dp); // expected-note{{instantiation}}
+  
+  X1<int*>::Inner4<int> id4;
+  id4.f2(ip, i, dp); // expected-note{{instantiation}}
+  
+  X1<int*>::Inner4<int>::value = 17;
+  i = X1<int*>::Inner4<int&>::value; // expected-note{{instantiation}}
+}
+
+
+template<typename T>
+struct X2 {
+  template<T *Ptr> // expected-error{{pointer to a reference}}
+  struct Inner;
+  
+  template<T Value> // expected-error{{cannot have type 'float'}}
+  struct Inner2;
+};
+
+X2<int&> x2a; // expected-note{{instantiation}}
+X2<float> x2b; // expected-note{{instantiation}}
+
+namespace N0 {
+  template<typename T>
+  struct X0 { };
+  
+  struct X1 {
+    template<typename T> void f(X0<T>& vals) { g(vals); }
+    template<typename T> void g(X0<T>& vals) { }
+  };
+  
+  void test(X1 x1, X0<int> x0i, X0<long> x0l) {
+    x1.f(x0i);
+    x1.f(x0l);
+  }  
+}
+
+namespace PR6239 {
+  template <typename T>  
+  struct X0 {  
+    class type {
+      typedef T E;    
+      template <E e>  // subsitute T for E and bug goes away
+      struct sfinae {  };  
+      
+      template <class U>  
+      typename sfinae<&U::operator=>::type test(int);  
+    };
+  };
+
+  template <typename T>  
+  struct X1 {  
+    typedef T E;    
+    template <E e>  // subsitute T for E and bug goes away
+    struct sfinae {  };  
+    
+    template <class U>  
+    typename sfinae<&U::operator=>::type test(int);  
+  };
+
+}
+
+namespace PR7587 {
+  template<typename> class X0;
+  template<typename> struct X1;
+  template<typename> class X2;
+
+  template<typename T> class X3
+  {
+    template<
+      template<typename> class TT,
+      typename U = typename X1<T>::type
+    > 
+    struct Inner {
+      typedef X2<TT<typename X1<T>::type> > Type;
+    };
+
+    const typename Inner<X0>::Type minCoeff() const;
+  };
+
+  template<typename T> class X3<T*>
+  {
+    template<
+      template<typename> class TT,
+      typename U = typename X1<T>::type
+    > 
+    struct Inner {
+      typedef X2<TT<typename X1<T>::type> > Type;
+    };
+
+    const typename Inner<X0>::Type minCoeff() const;
+  };
+
+}
+
+namespace PR7669 {
+  template<class> struct X {
+    template<class> struct Y {
+      template<int,class> struct Z;
+      template<int Dummy> struct Z<Dummy,int> {};
+    };
+  };
+
+  void a()
+  {
+    X<int>::Y<int>::Z<0,int>();
+  }
+}
+
+namespace PR8489 {
+  template <typename CT>
+  class C {
+    template<typename FT>
+    void F() {} // expected-note{{FT}}
+  };
+  void f() {
+    C<int> c;
+    c.F(); // expected-error{{no matching member function}}
+  }
+}
+
+namespace rdar8986308 {
+  template <bool> struct __static_assert_test;
+  template <> struct __static_assert_test<true> {};
+  template <unsigned> struct __static_assert_check {};
+
+  namespace std {
+
+    template <class _Tp, class _Up>
+    struct __has_rebind
+    {
+    private:
+      struct __two {char _; char __;};
+      template <class _Xp> static __two __test(...);
+      template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0);
+    public:
+      static const bool value = sizeof(__test<_Tp>(0)) == 1;
+    };
+
+  }
+
+  template <class T> struct B1 {};
+
+  template <class T>
+  struct B
+  {
+    template <class U> struct rebind {typedef B1<U> other;};
+  };
+
+  template <class T, class U> struct D1 {};
+
+  template <class T, class U>
+  struct D
+  {
+    template <class V> struct rebind {typedef D1<V, U> other;};
+  };
+
+  int main()
+  {
+    typedef __static_assert_check<sizeof(__static_assert_test<((std::__has_rebind<B<int>, double>::value))>)> __t64;
+    typedef __static_assert_check<sizeof(__static_assert_test<((std::__has_rebind<D<char, int>, double>::value))>)> __t64;
+  }
+
+}
diff --git a/clang/test/SemaTemplate/instantiate-method.cpp b/clang/test/SemaTemplate/instantiate-method.cpp
new file mode 100644
index 0000000..363115d
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-method.cpp
@@ -0,0 +1,177 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T>
+class X {
+public:
+  void f(T x); // expected-error{{argument may not have 'void' type}}
+  void g(T*);
+
+  static int h(T, T); // expected-error {{argument may not have 'void' type}}
+};
+
+int identity(int x) { return x; }
+
+void test(X<int> *xi, int *ip, X<int(int)> *xf) {
+  xi->f(17);
+  xi->g(ip);
+  xf->f(&identity);
+  xf->g(identity);
+  X<int>::h(17, 25);
+  X<int(int)>::h(identity, &identity);
+}
+
+void test_bad() {
+  X<void> xv; // expected-note{{in instantiation of template class 'X<void>' requested here}}
+}
+
+template<typename T, typename U>
+class Overloading {
+public:
+  int& f(T, T); // expected-note{{previous declaration is here}}
+  float& f(T, U); // expected-error{{functions that differ only in their return type cannot be overloaded}}
+};
+
+void test_ovl(Overloading<int, long> *oil, int i, long l) {
+  int &ir = oil->f(i, i);
+  float &fr = oil->f(i, l);
+}
+
+void test_ovl_bad() {
+  Overloading<float, float> off; // expected-note{{in instantiation of template class 'Overloading<float, float>' requested here}}
+}
+
+template<typename T>
+class HasDestructor {
+public:
+  virtual ~HasDestructor() = 0;
+};
+
+int i = sizeof(HasDestructor<int>); // FIXME: forces instantiation, but 
+                // the code below should probably instantiate by itself.
+int abstract_destructor[__is_abstract(HasDestructor<int>)? 1 : -1];
+
+
+template<typename T>
+class Constructors {
+public:
+  Constructors(const T&);
+  Constructors(const Constructors &other);
+};
+
+void test_constructors() {
+  Constructors<int> ci1(17);
+  Constructors<int> ci2 = ci1;
+}
+
+
+template<typename T>
+struct ConvertsTo {
+  operator T();
+};
+
+void test_converts_to(ConvertsTo<int> ci, ConvertsTo<int *> cip) {
+  int i = ci;
+  int *ip = cip;
+}
+
+// PR4660
+template<class T> struct A0 { operator T*(); };
+template<class T> struct A1;
+
+int *a(A0<int> &x0, A1<int> &x1) {
+  int *y0 = x0;
+  int *y1 = x1; // expected-error{{no viable conversion}}
+}
+
+struct X0Base {
+  int &f();
+  int& g(int);
+  static double &g(double);
+};
+
+template<typename T>
+struct X0 : X0Base {
+};
+
+template<typename U>
+struct X1 : X0<U> {
+  int &f2() { 
+    return X0Base::f();
+  }
+};
+
+void test_X1(X1<int> x1i) {
+  int &ir = x1i.f2();
+}
+
+template<typename U>
+struct X2 : X0Base, U {
+  int &f2() { return X0Base::f(); }
+};
+
+template<typename T>
+struct X3 {
+  void test(T x) {
+    double& d1 = X0Base::g(x);
+  }
+};
+
+
+template struct X3<double>;
+
+// Don't try to instantiate this, it's invalid.
+namespace test1 {
+  template <class T> class A {};
+  template <class T> class B {
+    void foo(A<test1::Undeclared> &a) // expected-error {{no member named 'Undeclared' in namespace 'test1'}}
+    {}
+  };
+  template class B<int>;
+}
+
+namespace PR6947 {
+  template< class T > 
+  struct X {
+    int f0( )      
+    {
+      typedef void ( X::*impl_fun_ptr )( );
+      impl_fun_ptr pImpl = &X::template
+        f0_impl1<int>;
+    }
+  private:                  
+    int f1() {
+    }
+    template< class Processor>                  
+    void f0_impl1( )                 
+    {
+    }
+  };
+
+  char g0() {
+    X<int> pc;
+    pc.f0();
+  }
+
+}
+
+namespace PR7022 {
+  template <typename > 
+  struct X1
+  {
+    typedef int state_t( );
+    state_t g ;
+  };
+
+  template <  typename U = X1<int> > struct X2
+  {
+    X2( U = U())
+    {
+    }
+  };
+
+  void m(void)
+  {
+    typedef X2<> X2_type;
+    X2_type c;
+  }
+
+}
diff --git a/clang/test/SemaTemplate/instantiate-non-dependent-types.cpp b/clang/test/SemaTemplate/instantiate-non-dependent-types.cpp
new file mode 100644
index 0000000..a0005c5
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-non-dependent-types.cpp
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T>
+struct X1 {
+  static void member() { T* x = 1; } // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
+};
+
+template<void(*)()> struct instantiate { };
+
+template<typename T>
+struct X2 {
+  typedef instantiate<&X1<int>::member> i; // expected-note{{in instantiation of}}
+};
+
+X2<int> x; 
diff --git a/clang/test/SemaTemplate/instantiate-non-type-template-parameter.cpp b/clang/test/SemaTemplate/instantiate-non-type-template-parameter.cpp
new file mode 100644
index 0000000..027c1e8
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-non-type-template-parameter.cpp
@@ -0,0 +1,55 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// PR5311
+template<typename T>
+class StringSwitch {
+public:
+  template<unsigned N>
+  void Case(const char (&S)[N], const int & Value) {
+  }
+};
+
+void test_stringswitch(int argc, char *argv[]) {
+  (void)StringSwitch<int>();
+}
+
+namespace PR6986 {
+  template<class Class,typename Type,Type Class::*> 
+  struct non_const_member_base
+  {
+  };
+
+  template<class Class,typename Type,Type Class::*PtrToMember> 
+  struct member: non_const_member_base<Class,Type,PtrToMember>
+  {
+  };
+
+  struct test_class
+  {
+    int int_member;
+  };
+  typedef member< test_class,const int,&test_class::int_member > ckey_m;
+  void test()
+  {
+    ckey_m m;
+  }
+}
+
+namespace rdar8980215 {
+  enum E { E1, E2, E3 };
+
+  template<typename T, E e = E2>
+  struct X0 { 
+    X0() {}
+    template<typename U> X0(const X0<U, e> &);
+  };
+
+  template<typename T>
+  struct X1 : X0<T> { 
+    X1() {}
+    template<typename U> X1(const X1<U> &x) : X0<T>(x) { }
+  };
+
+  X1<int> x1i;
+  X1<float> x1f(x1i);
+}
diff --git a/clang/test/SemaTemplate/instantiate-objc-1.mm b/clang/test/SemaTemplate/instantiate-objc-1.mm
new file mode 100644
index 0000000..2780f8e
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-objc-1.mm
@@ -0,0 +1,48 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Obj-C string literal expressions
+template <typename T> struct StringTest {
+  void f() {
+    (void)@"Hello";
+  }
+};
+
+template struct StringTest<int>;
+template struct StringTest<double>;
+
+// @selector expressions
+template <typename T> struct SelectorTest {
+  SEL f() {
+    return @selector(multiple:arguments:);
+  }
+  SEL f2() {
+    return @selector(multiple:arguments:);
+  }
+};
+
+template struct SelectorTest<int>;
+template struct SelectorTest<double>;
+
+// @protocol expressions
+@protocol P
+@end
+
+template <typename T> struct ProtocolTest {
+  void f() {
+    (void)@protocol(P);
+  }
+};
+
+template struct ProtocolTest<int>;
+template struct ProtocolTest<double>;
+
+// @encode expressions
+template <typename T> struct EncodeTest {
+  static const char *encode(T t) { 
+    return @encode(T);
+  }
+};
+
+template struct EncodeTest<int>;
+template struct EncodeTest<double>;
+template struct EncodeTest<wchar_t>;
diff --git a/clang/test/SemaTemplate/instantiate-overload-candidates.cpp b/clang/test/SemaTemplate/instantiate-overload-candidates.cpp
new file mode 100644
index 0000000..5b7e60d
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-overload-candidates.cpp
@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// This is the function actually selected during overload resolution, and the
+// only one defined.
+template <typename T> void f(T*, int) {}
+
+template <typename T> struct S;
+template <typename T> struct S_ : S<T> { typedef int type; }; // expected-note{{in instantiation}}
+template <typename T> struct S {
+  // Force T to have a complete type here so we can observe instantiations with
+  // incomplete types.
+  T t; // expected-error{{field has incomplete type}}
+};
+
+// Provide a bad class and an overload that instantiates templates with it.
+class NoDefinition; // expected-note{{forward declaration}}
+template <typename T> S_<NoDefinition>::type f(T*, NoDefinition*); // expected-note{{in instantiation}}
+
+void test(int x) {
+  f(&x, 0);
+}
diff --git a/clang/test/SemaTemplate/instantiate-overloaded-arrow.cpp b/clang/test/SemaTemplate/instantiate-overloaded-arrow.cpp
new file mode 100644
index 0000000..ee36427
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-overloaded-arrow.cpp
@@ -0,0 +1,20 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// PR5488
+
+struct X {
+  int x;
+};
+
+struct Iter {
+  X* operator->();
+};
+
+template <typename T>
+void Foo() {
+  (void)Iter()->x;
+}
+
+void Func() {
+  Foo<int>();
+}
+
diff --git a/clang/test/SemaTemplate/instantiate-self.cpp b/clang/test/SemaTemplate/instantiate-self.cpp
new file mode 100644
index 0000000..cfe9025
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-self.cpp
@@ -0,0 +1,89 @@
+// RUN: %clang_cc1 -std=c++11 -verify %s
+
+// Check that we deal with cases where the instantiation of a class template
+// recursively requires the instantiation of the same template.
+namespace test1 {
+  template<typename T> struct A {
+    struct B { // expected-note {{not complete until the closing '}'}}
+      B b; // expected-error {{has incomplete type 'test1::A<int>::B'}}
+    };
+    B b; // expected-note {{in instantiation of}}
+  };
+  A<int> a; // expected-note {{in instantiation of}}
+}
+
+namespace test2 {
+  template<typename T> struct A {
+    struct B {
+      struct C {};
+      char c[1 + C()]; // expected-error {{invalid operands to binary expression}}
+      friend constexpr int operator+(int, C) { return 4; }
+    };
+    B b; // expected-note {{in instantiation of}}
+  };
+  A<int> a; // expected-note {{in instantiation of}}
+}
+
+namespace test3 {
+  // PR12317
+  template<typename T> struct A {
+    struct B {
+      enum { Val = 1 };
+      char c[1 + Val]; // ok
+    };
+    B b;
+  };
+  A<int> a;
+}
+
+namespace test4 {
+  template<typename T> struct M { typedef int type; };
+  template<typename T> struct A {
+    struct B { // expected-note {{not complete until the closing '}'}}
+      int k[typename A<typename M<T>::type>::B().k[0] + 1]; // expected-error {{incomplete type}}
+    };
+    B b; // expected-note {{in instantiation of}}
+  };
+  A<int> a; // expected-note {{in instantiation of}}
+}
+
+// FIXME: PR12298: Recursive constexpr function template instantiation leads to
+// stack overflow.
+#if 0
+namespace test5 {
+  template<typename T> struct A {
+    constexpr T f(T k) { return g(k); }
+    constexpr T g(T k) {
+      return k ? f(k-1)+1 : 0;
+    }
+  };
+  // This should be accepted.
+  constexpr int x = A<int>().f(5);
+}
+
+namespace test6 {
+  template<typename T> constexpr T f(T);
+  template<typename T> constexpr T g(T t) {
+    typedef int arr[f(T())];
+    return t;
+  }
+  template<typename T> constexpr T f(T t) {
+    typedef int arr[g(T())];
+    return t;
+  }
+  // This should be ill-formed.
+  int n = f(0);
+}
+
+namespace test7 {
+  template<typename T> constexpr T g(T t) {
+    return t;
+  }
+  template<typename T> constexpr T f(T t) {
+    typedef int arr[g(T())];
+    return t;
+  }
+  // This should be accepted.
+  int n = f(0);
+}
+#endif
diff --git a/clang/test/SemaTemplate/instantiate-sizeof.cpp b/clang/test/SemaTemplate/instantiate-sizeof.cpp
new file mode 100644
index 0000000..00d63d0
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-sizeof.cpp
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
+// Make sure we handle contexts correctly with sizeof
+template<typename T> void f(T n) {
+  int buffer[n];
+  [] { int x = sizeof(sizeof(buffer)); }();
+}
+int main() {
+  f<int>(1);
+}
diff --git a/clang/test/SemaTemplate/instantiate-static-var.cpp b/clang/test/SemaTemplate/instantiate-static-var.cpp
new file mode 100644
index 0000000..f309f29
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-static-var.cpp
@@ -0,0 +1,116 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T, T Divisor>
+class X {
+public:
+  static const T value = 10 / Divisor; // expected-error{{in-class initializer for static data member is not a constant expression}}
+};
+
+int array1[X<int, 2>::value == 5? 1 : -1];
+X<int, 0> xi0; // expected-note{{in instantiation of template class 'X<int, 0>' requested here}}
+
+
+template<typename T>
+class Y {
+  static const T value = 0; // expected-warning{{in-class initializer for static data member of type 'const float' is a GNU extension}}
+};
+
+Y<float> fy; // expected-note{{in instantiation of template class 'Y<float>' requested here}}
+
+
+// out-of-line static member variables
+
+template<typename T>
+struct Z {
+  static T value;
+};
+
+template<typename T>
+T Z<T>::value; // expected-error{{no matching constructor}}
+
+struct DefCon {};
+
+struct NoDefCon { 
+  NoDefCon(const NoDefCon&); // expected-note{{candidate constructor}}
+};
+
+void test() {
+  DefCon &DC = Z<DefCon>::value;
+  NoDefCon &NDC = Z<NoDefCon>::value; // expected-note{{instantiation}}
+}
+
+// PR5609
+struct X1 {
+  ~X1();  // The errors won't be triggered without this dtor.
+};
+
+template <typename T>
+struct Y1 {
+  static char Helper(T);
+  static const int value = sizeof(Helper(T()));
+};
+
+struct X2 {
+  virtual ~X2();
+};
+
+namespace std {
+  class type_info { };
+}
+
+template <typename T>
+struct Y2 {
+  static T &Helper();
+  static const int value = sizeof(typeid(Helper()));
+};
+
+template <int>
+struct Z1 {};
+
+void Test() {
+  Z1<Y1<X1>::value> x;
+  int y[Y1<X1>::value];
+  Z1<Y2<X2>::value> x2;
+  int y2[Y2<X2>::value];
+}
+
+// PR5672
+template <int n>
+struct X3 {};
+
+class Y3 {
+ public:
+  ~Y3();  // The error isn't triggered without this dtor.
+
+  void Foo(X3<1>);
+};
+
+template <typename T>
+struct SizeOf {
+  static const int value = sizeof(T);
+};
+
+void MyTest3() {
+   Y3().Foo(X3<SizeOf<char>::value>());
+}
+
+namespace PR6449 {
+  template<typename T>    
+  struct X0  {
+    static const bool var = false;
+  };
+
+  template<typename T>
+  const bool X0<T>::var;
+
+  template<typename T>
+  struct X1 : public X0<T> {
+    static const bool var = false;
+  };
+
+  template<typename T>      
+  const bool X1<T>::var;
+
+  template class X0<char>;
+  template class X1<char>;
+
+}
diff --git a/clang/test/SemaTemplate/instantiate-subscript.cpp b/clang/test/SemaTemplate/instantiate-subscript.cpp
new file mode 100644
index 0000000..8c119ec
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-subscript.cpp
@@ -0,0 +1,41 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+
+struct Sub0 {
+  int &operator[](int);
+};
+
+struct Sub1 {
+  long &operator[](long); // expected-note{{candidate function}}
+};
+
+struct ConvertibleToInt {
+  operator int();
+};
+
+template<typename T, typename U, typename Result>
+struct Subscript0 {
+  void test(T t, U u) {
+    Result &result = t[u]; // expected-error{{no viable overloaded operator[] for type}}
+  }
+};
+
+template struct Subscript0<int*, int, int&>;
+template struct Subscript0<Sub0, int, int&>;
+template struct Subscript0<Sub1, ConvertibleToInt, long&>;
+template struct Subscript0<Sub1, Sub0, long&>; // expected-note{{instantiation}}
+
+// PR5345
+template <typename T>
+struct S {
+  bool operator[](int n) const { return true; }
+};
+
+template <typename T>
+void Foo(const S<int>& s, T x) {
+  if (s[0]) {}
+}
+
+void Bar() {
+  Foo(S<int>(), 0);
+}
diff --git a/clang/test/SemaTemplate/instantiate-template-template-parm.cpp b/clang/test/SemaTemplate/instantiate-template-template-parm.cpp
new file mode 100644
index 0000000..a70c7e8
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-template-template-parm.cpp
@@ -0,0 +1,97 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<template<typename T> class MetaFun, typename Value>
+struct apply {
+  typedef typename MetaFun<Value>::type type;
+};
+
+template<class T>
+struct add_pointer {
+  typedef T* type;
+};
+
+template<class T>
+struct add_reference {
+  typedef T& type;
+};
+
+int i;
+apply<add_pointer, int>::type ip = &i;
+apply<add_reference, int>::type ir = i;
+apply<add_reference, float>::type fr = i; // expected-error{{non-const lvalue reference to type 'float' cannot bind to a value of unrelated type 'int'}}
+
+// Template template parameters
+template<int> struct B; // expected-note{{has a different type 'int'}}
+
+template<typename T, 
+         template<T Value> class X> // expected-error{{cannot have type 'float'}} \
+                                    // expected-note{{with type 'long'}}
+struct X0 { };
+
+X0<int, B> x0b1;
+X0<float, B> x0b2; // expected-note{{while substituting}}
+X0<long, B> x0b3; // expected-error{{template template argument has different template parameters}}
+
+template<template<int V> class TT> // expected-note{{parameter with type 'int'}}
+struct X1 { };
+
+template<typename T, template<T V> class TT>
+struct X2 {
+  X1<TT> x1; // expected-error{{has different template parameters}}
+};
+
+template<int V> struct X3i { };
+template<long V> struct X3l { }; // expected-note{{different type 'long'}}
+
+X2<int, X3i> x2okay;
+X2<long, X3l> x2bad; // expected-note{{instantiation}}
+
+template <typename T, template <T, T> class TT, class R = TT<1, 2> >
+struct Comp {
+  typedef R r1;
+  template <T x, T y> struct gt {
+    static const bool result = x > y;
+  };
+  typedef gt<2, 1> r2;
+};
+
+template <int x, int y> struct lt {
+  static const bool result = x < y;
+};
+
+Comp<int, lt> c0;
+
+namespace PR8629 {
+  template<template<int> class TT> struct X0
+  {
+    static void apply();
+  };
+  template<int> struct Type { };
+
+  template<class T> struct X1
+  {
+    template<class U> struct Inner;
+
+    template<class U> void g()
+    {
+      typedef Inner<U> Init;
+      X0<Init::template VeryInner>::apply();
+    }
+    template<int N> void f ()
+    {
+      g<Type<N> >();
+    }
+  };
+  template<class T> template<class U> struct X1<T>::Inner
+  {
+    template<int> struct VeryInner {
+    };
+  };
+  struct X1Container
+  {
+    X1Container()
+    {
+      simplex_.f<0>();
+    }
+    X1<double> simplex_;
+  };
+}
diff --git a/clang/test/SemaTemplate/instantiate-try-catch.cpp b/clang/test/SemaTemplate/instantiate-try-catch.cpp
new file mode 100644
index 0000000..89cae03
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-try-catch.cpp
@@ -0,0 +1,31 @@
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -std=c++11 -verify %s
+
+template<typename T> struct TryCatch0 {
+  void f() {
+    try {
+    } catch (T&&) { // expected-error 2{{cannot catch exceptions by rvalue reference}}
+    }
+  }
+};
+
+template struct TryCatch0<int&>; // okay
+template struct TryCatch0<int&&>; // expected-note{{instantiation}}
+template struct TryCatch0<int>; // expected-note{{instantiation}}
+
+
+namespace PR10232 {
+  template <typename T>
+  class Templated {
+    struct Exception {
+    private:
+      Exception(const Exception&); // expected-note{{declared private here}}
+    };
+    void exception() {
+      try {
+      } catch(Exception e) {  // expected-error{{calling a private constructor of class 'PR10232::Templated<int>::Exception'}}
+      }
+    }
+  };
+
+  template class Templated<int>; // expected-note{{in instantiation of member function 'PR10232::Templated<int>::exception' requested here}}
+}
diff --git a/clang/test/SemaTemplate/instantiate-type.cpp b/clang/test/SemaTemplate/instantiate-type.cpp
new file mode 100644
index 0000000..f5d0270
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-type.cpp
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -fsyntax-only %s
+
+int* f(int);
+float *f(...);
+
+template<typename T>
+struct X {
+  typedef typeof(T*) typeof_type;
+  typedef typeof(f(T())) typeof_expr;
+};
+
+int *iptr0;
+float *fptr0;
+X<int>::typeof_type &iptr1 = iptr0;
+
+X<int>::typeof_expr &iptr2 = iptr0;
+X<float*>::typeof_expr &fptr1 = fptr0;
diff --git a/clang/test/SemaTemplate/instantiate-typedef.cpp b/clang/test/SemaTemplate/instantiate-typedef.cpp
new file mode 100644
index 0000000..4e6cd24
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-typedef.cpp
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T>
+struct add_pointer {
+  typedef T* type; // expected-error{{'type' declared as a pointer to a reference}}
+};
+
+add_pointer<int>::type test1(int * ptr) { return ptr; }
+
+add_pointer<float>::type test2(int * ptr) { 
+  return ptr; // expected-error{{cannot initialize return object of type 'add_pointer<float>::type' (aka 'float *') with an lvalue of type 'int *'}}
+}
+
+add_pointer<int&>::type // expected-note{{in instantiation of template class 'add_pointer<int &>' requested here}}
+test3(); 
diff --git a/clang/test/SemaTemplate/instantiate-typeof.cpp b/clang/test/SemaTemplate/instantiate-typeof.cpp
new file mode 100644
index 0000000..92873cb
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-typeof.cpp
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
+// Make sure we correctly treat __typeof as potentially-evaluated when appropriate
+template<typename T> void f(T n) {
+  int buffer[n]; // expected-note {{declared here}}
+  [] { __typeof(buffer) x; }(); // expected-error {{variable 'buffer' with variably modified type cannot be captured in a lambda expression}}
+}
+int main() {
+  f<int>(1); // expected-note {{in instantiation}}
+}
diff --git a/clang/test/SemaTemplate/instantiate-using-decl.cpp b/clang/test/SemaTemplate/instantiate-using-decl.cpp
new file mode 100644
index 0000000..1bfcb7a
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiate-using-decl.cpp
@@ -0,0 +1,82 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+namespace test0 {
+  namespace N { }
+
+  template<typename T>
+  struct A {
+    void f();
+  };
+
+  template<typename T>
+  struct B : A<T> {
+    using A<T>::f;
+
+    void g() {
+      using namespace N;
+      f();
+    }
+  };
+
+  template struct B<int>;
+}
+
+namespace test1 {
+  template <class Derived> struct Visitor1 {
+    void Visit(struct Object1*);
+  };
+  template <class Derived> struct Visitor2 {
+    void Visit(struct Object2*); // expected-note {{candidate function}}
+  };
+
+  template <class Derived> struct JoinVisitor
+      : Visitor1<Derived>, Visitor2<Derived> {
+    typedef Visitor1<Derived> Base1;
+    typedef Visitor2<Derived> Base2;
+
+    void Visit(struct Object1*);  // expected-note {{candidate function}}
+    using Base2::Visit;
+  };
+
+  class Knot : public JoinVisitor<Knot> {
+  };
+
+  void test() {
+    Knot().Visit((struct Object1*) 0);
+    Knot().Visit((struct Object2*) 0);
+    Knot().Visit((struct Object3*) 0); // expected-error {{no matching member function for call}}
+  }
+}
+
+// PR5847
+namespace test2 {
+  namespace ns {
+    void foo();
+  }
+
+  template <class T> void bar(T* ptr) {
+    using ns::foo;
+    foo();
+  }
+
+  template void bar(char *);
+}
+
+namespace test3 {
+  template <typename T> struct t {
+    struct s1 {
+      T f1() const;
+    };
+    struct s2 : s1 {
+      using s1::f1;
+      T f1() const;
+    };
+  };
+
+  void f2()
+  {
+    t<int>::s2 a;
+    t<int>::s2 const & b = a;
+    b.f1();
+  }
+}
diff --git a/clang/test/SemaTemplate/instantiation-backtrace.cpp b/clang/test/SemaTemplate/instantiation-backtrace.cpp
new file mode 100644
index 0000000..21456e9
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiation-backtrace.cpp
@@ -0,0 +1,32 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T> struct A; // expected-note 4{{template is declared here}}
+
+template<typename T> struct B : A<T*> { }; // expected-error{{implicit instantiation of undefined template}} \
+// expected-error{{implicit instantiation of undefined template 'A<X *>'}}
+
+template<typename T> struct C : B<T> { } ; // expected-note{{instantiation of template class}}
+
+template<typename T> struct D : C<T> { }; // expected-note{{instantiation of template class}}
+
+template<typename T> struct E : D<T> { }; // expected-note{{instantiation of template class}}
+
+template<typename T> struct F : E<T(T)> { }; // expected-note{{instantiation of template class}}
+
+void f() {
+ (void)sizeof(F<int>); // expected-note{{instantiation of template class}}
+}
+
+typedef struct { } X;
+
+void g() {
+  (void)sizeof(B<X>); // expected-note{{in instantiation of template class 'B<X>' requested here}}
+}
+
+template<typename T> 
+struct G : A<T>, // expected-error{{implicit instantiation of undefined template 'A<int>'}}
+  A<T*> // expected-error{{implicit instantiation of undefined template 'A<int *>'}}
+  { };
+
+void h() {
+  (void)sizeof(G<int>); // expected-note{{in instantiation of template class 'G<int>' requested here}}
+}
diff --git a/clang/test/SemaTemplate/instantiation-default-1.cpp b/clang/test/SemaTemplate/instantiation-default-1.cpp
new file mode 100644
index 0000000..99154a5
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiation-default-1.cpp
@@ -0,0 +1,102 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T, typename U = const T> struct Def1;
+
+template<> struct Def1<int> { 
+  void foo();
+};
+
+template<> struct Def1<const int> { // expected-note{{previous definition is here}}
+  void bar();
+};
+
+template<> struct Def1<int&> {
+  void wibble();
+};
+
+void test_Def1(Def1<int, const int> *d1, Def1<const int, const int> *d2,
+               Def1<int&, int&> *d3) {
+  d1->foo();
+  d2->bar();
+  d3->wibble();
+}
+
+template<typename T,  // FIXME: bad error message below, needs better location info
+         typename T2 = const T*>  // expected-error{{'T2' declared as a pointer to a reference}}
+  struct Def2;
+
+template<> struct Def2<int> { 
+  void foo();
+};
+
+void test_Def2(Def2<int, int const*> *d2) {
+  d2->foo();
+}
+
+typedef int& int_ref_t;
+Def2<int_ref_t> *d2; // expected-note{{in instantiation of default argument for 'Def2<int &>' required here}}
+
+
+template<> struct Def1<const int, const int> { }; // expected-error{{redefinition of 'Def1<const int>'}}
+
+template<typename T, typename T2 = T&> struct Def3;
+
+template<> struct Def3<int> { 
+  void foo();
+};
+
+template<> struct Def3<int&> { 
+  void bar();
+};
+
+void test_Def3(Def3<int, int&> *d3a, Def3<int&, int&> *d3b) {
+  d3a->foo();
+  d3b->bar();
+}
+
+
+template<typename T, typename T2 = T[]> struct Def4;
+
+template<> struct Def4<int> {
+  void foo();
+};
+
+void test_Def4(Def4<int, int[]> *d4a) {
+  d4a->foo();
+}
+
+template<typename T, typename T2 = T const[12]> struct Def5;
+
+template<> struct Def5<int> {
+  void foo();
+};
+
+template<> struct Def5<int, int const[13]> {
+  void bar();
+};
+
+void test_Def5(Def5<int, const int[12]> *d5a, Def5<int, const int[13]> *d5b) {
+  d5a->foo();
+  d5b->bar();
+}
+
+template<typename R, typename Arg1, typename Arg2 = Arg1,
+         typename FuncType = R (*)(Arg1, Arg2)>
+  struct Def6;
+
+template<> struct Def6<int, float> { 
+  void foo();
+};
+
+template<> struct Def6<bool, int[5], float(double, double)> {
+  void bar();
+};
+
+bool test_Def6(Def6<int, float, float> *d6a, 
+               Def6<int, float, float, int (*)(float, float)> *d6b,
+               Def6<bool, int[5], float(double, double),
+                    bool(*)(int*, float(*)(double, double))> *d6c) {
+  d6a->foo();
+  d6b->foo();
+  d6c->bar();
+  return d6a == d6b;
+}
diff --git a/clang/test/SemaTemplate/instantiation-default-2.cpp b/clang/test/SemaTemplate/instantiation-default-2.cpp
new file mode 100644
index 0000000..5a744a0
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiation-default-2.cpp
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T, T Value> struct Constant; // expected-note{{template parameter is declared here}} \
+// FIXME: bad location expected-error{{a non-type template parameter cannot have type 'float'}}
+
+Constant<int, 5> *c1;
+
+int x;
+float f(int, double);
+
+Constant<int&, x> *c2;
+Constant<int*, &x> *c3;
+Constant<float (*)(int, double), f> *c4;
+Constant<float (*)(int, double), &f> *c5;
+
+Constant<float (*)(int, int), f> *c6; // expected-error{{non-type template argument of type 'float (int, double)' cannot be converted to a value of type 'float (*)(int, int)'}}
+
+Constant<float, 0> *c7; // expected-note{{while substituting}}
diff --git a/clang/test/SemaTemplate/instantiation-default-3.cpp b/clang/test/SemaTemplate/instantiation-default-3.cpp
new file mode 100644
index 0000000..dae6b18
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiation-default-3.cpp
@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T> struct A { };
+
+template<typename T, typename U = A<T*> >
+  struct B : U { };
+
+template<>
+struct A<int*> { 
+  void foo();
+};
+
+template<>
+struct A<float*> { 
+  void bar();
+};
+
+void test(B<int> *b1, B<float> *b2) {
+  b1->foo();
+  b2->bar();
+}
diff --git a/clang/test/SemaTemplate/instantiation-depth.cpp b/clang/test/SemaTemplate/instantiation-depth.cpp
new file mode 100644
index 0000000..8e1b803
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiation-depth.cpp
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -ftemplate-depth 5 -ftemplate-backtrace-limit 4 %s
+// RUN: %clang -fsyntax-only -Xclang -verify -ftemplate-depth-5 -ftemplate-backtrace-limit=4 %s
+// RUN: %clang -fsyntax-only -Xclang -verify -ftemplate-depth=5 -ftemplate-backtrace-limit=4 %s
+
+template<typename T> struct X : X<T*> { }; \
+// expected-error{{recursive template instantiation exceeded maximum depth of 5}} \
+// expected-note 3 {{instantiation of template class}} \
+// expected-note {{skipping 2 contexts in backtrace}} \
+// expected-note {{use -ftemplate-depth=N to increase recursive template instantiation depth}}
+
+void test() { 
+  (void)sizeof(X<int>); // expected-note {{instantiation of template class}}
+}
diff --git a/clang/test/SemaTemplate/instantiation-order.cpp b/clang/test/SemaTemplate/instantiation-order.cpp
new file mode 100644
index 0000000..e058a5b
--- /dev/null
+++ b/clang/test/SemaTemplate/instantiation-order.cpp
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -std=c++11 -verify %s
+
+// From core issue 1227.
+
+template <class T> struct A { using X = typename T::X; }; // expected-error {{no members}}
+template <class T> typename T::X f(typename A<T>::X);
+template <class T> void f(...) {}
+template <class T> auto g(typename A<T>::X) -> typename T::X; // expected-note {{here}} expected-note {{substituting}}
+template <class T> void g(...) {}
+
+void h()
+{
+  f<int>(0); // ok, SFINAE in return type
+  g<int>(0); // not ok, substitution inside A<int> is a hard error
+}
diff --git a/clang/test/SemaTemplate/issue150.cpp b/clang/test/SemaTemplate/issue150.cpp
new file mode 100644
index 0000000..af3b93c
--- /dev/null
+++ b/clang/test/SemaTemplate/issue150.cpp
@@ -0,0 +1,107 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Core issue 150: Template template parameters and default arguments
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+namespace PR9353 {
+  template<class _T, class Traits> class IM;
+
+  template <class T, class Trt, 
+            template<class _T, class Traits = int> class IntervalMap>
+  void foo(IntervalMap<T,Trt>* m) { typedef IntervalMap<int> type; }
+
+  void f(IM<int, int>* m) { foo(m); }
+}
+
+namespace PR9400 {
+  template<template <typename T, typename = T > class U> struct A
+  {
+    template<int> U<int> foo();
+  };
+
+  template <typename T, typename = T>
+  struct s {
+  };
+
+  void f() {
+    A<s> x;
+    x.foo<2>();
+  }
+}
+
+namespace MultiReplace {
+  template<typename Z, 
+           template<typename T, typename U = T *, typename V = U const> class TT>
+  struct X {
+    typedef TT<Z> type;
+  };
+
+  template<typename T, typename = int, typename = float> 
+  struct Y { };
+
+  int check0[is_same<X<int, Y>::type, Y<int, int*, int* const> >::value? 1 : -1];
+}
+
+namespace MultiReplacePartial {
+  template<typename First, typename Z, 
+           template<typename T, typename U = T *, typename V = U const> class TT>
+  struct X {
+    typedef TT<Z> type;
+  };
+
+  template<typename Z, 
+           template<typename T, typename U = T *, typename V = U const> class TT>
+  struct X<int, Z, TT> {
+    typedef TT<Z> type;
+  };
+
+  template<typename T, typename = int, typename = float> 
+  struct Y { };
+
+  int check0[is_same<X<int, int, Y>::type, Y<int, int*, int* const> >::value? 1 : -1];
+}
+
+namespace PR9016 {
+  template<typename > struct allocator ;
+  template<typename > struct less ;
+
+  template<class T, template<class> class Compare, class Default,
+           template<class> class Alloc>
+  struct interval_set { };
+
+  template <class X, template<class> class = less> struct interval_type_default {
+    typedef X type;
+  };
+
+  template <class T,
+            template<class _T, template<class> class Compare = PR9016::less,
+                     class = typename interval_type_default<_T,Compare>::type,
+                     template<class> class = allocator> class IntervalSet>
+  struct ZZZ
+  {
+    IntervalSet<T> IntervalSetT;
+  };
+  
+  template <class T, 
+            template<class _T, template<class> class Compare = PR9016::less,
+                     class = typename interval_type_default<_T,Compare>::type,
+                     template<class> class = allocator> class IntervalSet>
+  void int40()
+  {
+    IntervalSet<T> IntervalSetT;
+  }
+
+  void test() {
+    ZZZ<int, interval_set> zzz;
+    int40<int, interval_set>();
+  }
+}
diff --git a/clang/test/SemaTemplate/lookup-dependent-bases.cpp b/clang/test/SemaTemplate/lookup-dependent-bases.cpp
new file mode 100644
index 0000000..2710caf
--- /dev/null
+++ b/clang/test/SemaTemplate/lookup-dependent-bases.cpp
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify %s
+
+class C {
+public:
+   static void foo2() {  }
+};
+template <class T>
+class A {
+public:
+   typedef C D;
+};
+
+template <class T>
+class B : public A<T> {
+public:
+   void foo() {
+    D::foo2();
+   }
+};
diff --git a/clang/test/SemaTemplate/member-access-ambig.cpp b/clang/test/SemaTemplate/member-access-ambig.cpp
new file mode 100644
index 0000000..f8a01d5
--- /dev/null
+++ b/clang/test/SemaTemplate/member-access-ambig.cpp
@@ -0,0 +1,45 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// PR8439
+class A
+{
+};
+
+class B
+{
+public:
+  A & m;
+};
+
+class Base
+{
+public:
+  B &f();
+};
+
+class Derived1 : public Base { };
+
+class Derived2 : public Base { };
+
+class X : public B, public Derived2, public Derived1
+{
+public:
+  virtual void g();
+};
+
+void X::g()
+{
+  m.f<int>(); // expected-error{{no member named 'f' in 'A'}} \
+  // expected-error{{expected '(' for function-style cast}} \
+  // expected-error{{expected expression}}
+}
+
+namespace PR11134 {
+  template<typename Derived> class A;
+  template<typename Derived> class B : A<Derived> {
+    typedef A<Derived> Base;
+    using Base::member;
+    int member;
+  };
+}
+
diff --git a/clang/test/SemaTemplate/member-access-expr.cpp b/clang/test/SemaTemplate/member-access-expr.cpp
new file mode 100644
index 0000000..f1aa30e
--- /dev/null
+++ b/clang/test/SemaTemplate/member-access-expr.cpp
@@ -0,0 +1,149 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T>
+void call_f0(T x) {
+  x.Base::f0();
+}
+
+struct Base {
+  void f0();
+};
+
+struct X0 : Base { 
+  typedef Base CrazyBase;
+};
+
+void test_f0(X0 x0) {
+  call_f0(x0);
+}
+
+template<typename TheBase, typename T>
+void call_f0_through_typedef(T x) {
+  typedef TheBase Base2;
+  x.Base2::f0();
+}
+
+void test_f0_through_typedef(X0 x0) {
+  call_f0_through_typedef<Base>(x0);
+}
+
+template<typename TheBase, typename T>
+void call_f0_through_typedef2(T x) {
+  typedef TheBase CrazyBase; // expected-note{{current scope}}
+  x.CrazyBase::f0(); // expected-error{{ambiguous}} \
+                     // expected-error 2{{no member named}}
+}
+
+struct OtherBase { };
+
+struct X1 : Base, OtherBase { 
+  typedef OtherBase CrazyBase; // expected-note{{object type}}
+};
+
+void test_f0_through_typedef2(X0 x0, X1 x1) {
+  call_f0_through_typedef2<Base>(x0);
+  call_f0_through_typedef2<OtherBase>(x1); // expected-note{{instantiation}}
+  call_f0_through_typedef2<Base>(x1); // expected-note{{instantiation}}
+}
+
+
+struct X2 {
+  operator int() const;
+};
+
+template<typename T, typename U>
+T convert(const U& value) {
+  return value.operator T(); // expected-error{{operator long}}
+}
+
+void test_convert(X2 x2) {
+  convert<int>(x2);
+  convert<long>(x2); // expected-note{{instantiation}}
+}
+
+template<typename T>
+void destruct(T* ptr) {
+  ptr->~T();
+  ptr->T::~T();
+}
+
+template<typename T>
+void destruct_intptr(int *ip) {
+  ip->~T();
+  ip->T::~T();
+}
+
+void test_destruct(X2 *x2p, int *ip) {
+  destruct(x2p);
+  destruct(ip);
+  destruct_intptr<int>(ip);
+}
+
+// PR5220
+class X3 {
+protected:
+  template <int> float* &f0();
+  template <int> const float* &f0() const;
+  void f1() {
+    (void)static_cast<float*>(f0<0>());
+  }
+  void f1() const{
+    (void)f0<0>();
+  }
+};
+
+// Fun with template instantiation and conversions
+struct X4 {
+  int& member();
+  float& member() const;
+};
+
+template<typename T>
+struct X5 {
+  void f(T* ptr) { int& ir = ptr->member(); }
+  void g(T* ptr) { float& fr = ptr->member(); }
+};
+
+void test_X5(X5<X4> x5, X5<const X4> x5c, X4 *xp, const X4 *cxp) {
+  x5.f(xp);
+  x5c.g(cxp);
+}
+
+// In theory we can do overload resolution at template-definition time on this.
+// We should at least not assert.
+namespace test4 {
+  struct Base {
+    template <class T> void foo() {}
+  };
+
+  template <class T> struct Foo : Base {
+    void test() {
+      foo<int>();
+    }
+  };
+}
+
+namespace test5 {
+  template<typename T>
+  struct X {
+    using T::value;
+
+    T &getValue() {
+      return &value;
+    }
+  };
+}
+
+// PR8739
+namespace test6 {
+  struct A {};
+  struct B {};
+  template <class T> class Base;
+  template <class T> class Derived : public Base<T> {
+    A *field;
+    void get(B **ptr) {
+      // It's okay if at some point we figure out how to diagnose this
+      // at instantiation time.
+      *ptr = field;
+    }
+  };
+}
diff --git a/clang/test/SemaTemplate/member-function-template.cpp b/clang/test/SemaTemplate/member-function-template.cpp
new file mode 100644
index 0000000..44954ed
--- /dev/null
+++ b/clang/test/SemaTemplate/member-function-template.cpp
@@ -0,0 +1,103 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+struct X {
+  template<typename T> T& f0(T);
+  
+  void g0(int i, double d) {
+    int &ir = f0(i);
+    double &dr = f0(d);
+  }
+  
+  template<typename T> T& f1(T);
+  template<typename T, typename U> U& f1(T, U);
+  
+  void g1(int i, double d) {
+    int &ir1 = f1(i);
+    int &ir2 = f1(d, i);
+    int &ir3 = f1(i, i);
+  }
+};
+
+void test_X_f0(X x, int i, float f) {
+  int &ir = x.f0(i);
+  float &fr = x.f0(f);
+}
+
+void test_X_f1(X x, int i, float f) {
+  int &ir1 = x.f1(i);
+  int &ir2 = x.f1(f, i);
+  int &ir3 = x.f1(i, i);
+}
+
+void test_X_f0_address() {
+  int& (X::*pm1)(int) = &X::f0;
+  float& (X::*pm2)(float) = &X::f0;
+}
+
+void test_X_f1_address() {
+  int& (X::*pm1)(int) = &X::f1;
+  float& (X::*pm2)(float) = &X::f1;
+  int& (X::*pm3)(float, int) = &X::f1;
+}
+
+void test_X_f0_explicit(X x, int i, long l) {
+  int &ir1 = x.f0<int>(i);
+  int &ir2 = x.f0<>(i);
+  long &il1 = x.f0<long>(i);
+}
+
+// PR4608
+class A { template <class x> x a(x z) { return z+y; } int y; };
+
+// PR5419
+struct Functor {
+  template <typename T>
+  bool operator()(const T& v) const {
+    return true;
+  }
+};
+
+void test_Functor(Functor f) {
+  f(1);
+}
+
+// Instantiation on ->
+template<typename T>
+struct X1 {
+  template<typename U> U& get();
+};
+
+template<typename T> struct X2; // expected-note{{here}}
+
+void test_incomplete_access(X1<int> *x1, X2<int> *x2) {
+  float &fr = x1->get<float>();
+  (void)x2->get<float>(); // expected-error{{implicit instantiation of undefined template}}
+}
+
+// Instantiation of template template parameters in a member function
+// template.
+namespace TTP {
+  template<int Dim> struct X {
+    template<template<class> class M, class T> void f(const M<T>&);
+  };
+
+  template<typename T> struct Y { };
+
+  void test_f(X<3> x, Y<int> y) { x.f(y); }
+}
+
+namespace PR7387 {
+  template <typename T> struct X {};
+
+  template <typename T1> struct S {
+    template <template <typename> class TC> void foo(const TC<T1>& arg);
+  };
+
+  template <typename T1> template <template <typename> class TC>
+  void S<T1>::foo(const TC<T1>& arg) {}
+
+  void test(const X<int>& x) {
+    S<int> s;
+    s.foo(x);
+  }
+}
diff --git a/clang/test/SemaTemplate/member-inclass-init-value-dependent.cpp b/clang/test/SemaTemplate/member-inclass-init-value-dependent.cpp
new file mode 100644
index 0000000..5bff7f2
--- /dev/null
+++ b/clang/test/SemaTemplate/member-inclass-init-value-dependent.cpp
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -emit-llvm-only %s
+// PR10290
+
+template<int Flags> struct foo {
+  int value = Flags && 0;
+};
+
+void test() {
+  foo<4> bar;
+}
+
+struct S {
+  S(int n);
+};
+template<typename> struct T {
+  S s = 0;
+};
+T<int> t;
diff --git a/clang/test/SemaTemplate/member-initializers.cpp b/clang/test/SemaTemplate/member-initializers.cpp
new file mode 100644
index 0000000..40f56b3
--- /dev/null
+++ b/clang/test/SemaTemplate/member-initializers.cpp
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T> struct A {
+  A() : j(10), i(10) { }
+  
+  int i;
+  int j;
+};
+
+template<typename T> struct B : A<T> {
+  B() : A<T>() { }
+};
+
diff --git a/clang/test/SemaTemplate/member-template-access-expr.cpp b/clang/test/SemaTemplate/member-template-access-expr.cpp
new file mode 100644
index 0000000..c95b57d
--- /dev/null
+++ b/clang/test/SemaTemplate/member-template-access-expr.cpp
@@ -0,0 +1,144 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename U, typename T>
+U f0(T t) {
+  return t.template get<U>();
+}
+
+template<typename U, typename T>
+int &f1(T t) {
+  // FIXME: When we pretty-print this, we lose the "template" keyword.
+  return t.U::template get<int&>();
+}
+
+struct X {
+  template<typename T> T get();
+};
+
+void test_f0(X x) {
+  int i = f0<int>(x);
+  int &ir = f0<int&>(x);
+}
+
+struct XDerived : public X {
+};
+
+void test_f1(XDerived xd) {
+  int &ir = f1<X>(xd);
+}
+
+// PR5213
+template <class T>
+struct A {};
+
+template<class T>
+class B
+{
+  A<T> a_;
+  
+public:
+  void destroy();
+};
+
+template<class T>
+void
+B<T>::destroy()
+{
+  a_.~A<T>();
+}
+
+void do_destroy_B(B<int> b) {
+  b.destroy();
+}
+
+struct X1 {
+  int* f1(int);
+  template<typename T> float* f1(T);
+  
+  static int* f2(int);
+  template<typename T> static float* f2(T);
+};
+
+void test_X1(X1 x1) {
+  float *fp1 = x1.f1<>(17);
+  float *fp2 = x1.f1<int>(3.14); // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+  int *ip1 = x1.f1(17);
+  float *ip2 = x1.f1(3.14);
+  
+  float* (X1::*mf1)(int) = &X1::f1;
+  float* (X1::*mf2)(int) = &X1::f1<>;
+  float* (X1::*mf3)(float) = &X1::f1<float>;
+  
+  float* (*fp3)(int) = &X1::f2;
+  float* (*fp4)(int) = &X1::f2<>;
+  float* (*fp5)(float) = &X1::f2<float>;  
+  float* (*fp6)(int) = X1::f2;
+  float* (*fp7)(int) = X1::f2<>;
+  float* (*fp8)(float) = X1::f2<float>;  
+}
+
+template<int A> struct X2 { 
+  int m;
+};
+
+template<typename T>
+struct X3 : T { };
+
+template<typename T>
+struct X4 {
+  template<typename U>
+  void f(X2<sizeof(X3<U>().U::m)>);
+};
+
+void f(X4<X3<int> > x4i) {
+  X2<sizeof(int)> x2;
+  x4i.f<X2<sizeof(int)> >(x2);
+}
+
+template<typename T>
+struct X5 {
+  template<typename U>
+  void f();
+  
+  void g() {
+    this->f<T*>();
+  }
+};
+
+namespace PR6021 {
+  template< class T1, class T2 >
+  class Outer
+  {
+  public: // Range operations
+    template< class X > X tmpl( const X* = 0 ) const;
+
+    struct Inner
+    {
+      const Outer& o;
+
+      template< class X >
+      operator X() const
+      {
+        return o.tmpl<X>();
+      }
+    };
+  };
+}
+
+namespace rdar8198511 {
+  template<int, typename U>
+  struct Base { 
+    void f();
+  };
+
+  template<typename T>
+  struct X0 : Base<1, T> { };
+
+  template<typename T>
+  struct X1 {
+    X0<int> x0;
+
+    void f() {
+      this->x0.Base<1, int>::f();
+    }
+  };
+}
diff --git a/clang/test/SemaTemplate/metafun-apply.cpp b/clang/test/SemaTemplate/metafun-apply.cpp
new file mode 100644
index 0000000..3a7408e
--- /dev/null
+++ b/clang/test/SemaTemplate/metafun-apply.cpp
@@ -0,0 +1,40 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+struct add_pointer {
+  template<typename T>
+  struct apply {
+    typedef T* type;
+  };
+};
+
+struct add_reference {
+  template<typename T>
+  struct apply {
+    typedef T& type; // expected-error{{cannot form a reference to 'void'}}
+  };
+};
+
+struct bogus {
+  struct apply {
+    typedef int type;
+  };
+};
+
+template<typename MetaFun, typename T>
+struct apply1 {
+  typedef typename MetaFun::template apply<T>::type type; // expected-note{{in instantiation of template class 'add_reference::apply<void>' requested here}} \
+  // expected-error{{'apply' following the 'template' keyword does not refer to a template}}
+};
+
+int i;
+apply1<add_pointer, int>::type ip = &i;
+apply1<add_reference, int>::type ir = i;
+apply1<add_reference, float>::type fr = i; // expected-error{{non-const lvalue reference to type 'float' cannot bind to a value of unrelated type 'int'}}
+
+void test() {
+  apply1<add_reference, void>::type t; // expected-note{{in instantiation of template class 'apply1<add_reference, void>' requested here}}
+
+  apply1<bogus, int>::type t2; // expected-note{{in instantiation of template class 'apply1<bogus, int>' requested here}}
+}
+
+
diff --git a/clang/test/SemaTemplate/missing-class-keyword-crash.cpp b/clang/test/SemaTemplate/missing-class-keyword-crash.cpp
new file mode 100644
index 0000000..f0eee2b
--- /dev/null
+++ b/clang/test/SemaTemplate/missing-class-keyword-crash.cpp
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+class G {};
+template <Foo> // expected-error{{unknown type name 'Foo'}} \
+               // expected-note{{template parameter is declared here}}
+class Bar {};
+
+class Bar<G> blah_test; // expected-error{{template argument for non-type template parameter must be an expression}}
diff --git a/clang/test/SemaTemplate/ms-function-specialization-class-scope.cpp b/clang/test/SemaTemplate/ms-function-specialization-class-scope.cpp
new file mode 100644
index 0000000..bda87f9
--- /dev/null
+++ b/clang/test/SemaTemplate/ms-function-specialization-class-scope.cpp
@@ -0,0 +1,71 @@
+// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify %s
+
+
+class A {
+public:
+	template <class U>
+    A(U p) {
+	}
+	template <>
+    A(int p) { // expected-warning{{explicit specialization of 'A' within class scope is a Microsoft extension}}
+	}
+	
+	template <class U>
+    void f(U p) { 
+	}
+
+	template <>
+    void f(int p) { // expected-warning{{explicit specialization of 'f' within class scope is a Microsoft extension}}
+	}
+
+	void f(int p) { 
+    }
+};
+
+void test1()
+{
+   A a(3);
+   char* b ;
+   a.f(b);
+   a.f<int>(99);
+   a.f(100);
+}
+
+
+
+
+template <class T>
+class B {
+public:
+	template <class U>
+    B(U p) { 
+	}
+	template <>
+    B(int p) { // expected-warning{{explicit specialization of 'B<T>' within class scope is a Microsoft extension}}
+	}
+	
+	template <class U>
+    void f(U p) {
+	  T y = 9;
+	}
+
+
+    template <>
+    void f(int p) { // expected-warning{{explicit specialization of 'f' within class scope is a Microsoft extension}}
+	  T a = 3;
+	}
+
+	void f(int p) { 
+ 	  T a = 3;
+    }
+};
+
+void test2()
+{
+   B<char> b(3);
+   char* ptr;
+   b.f(ptr);
+   b.f<int>(99);
+   b.f(100);
+}
+
diff --git a/clang/test/SemaTemplate/ms-if-exists.cpp b/clang/test/SemaTemplate/ms-if-exists.cpp
new file mode 100644
index 0000000..04f4a63
--- /dev/null
+++ b/clang/test/SemaTemplate/ms-if-exists.cpp
@@ -0,0 +1,68 @@
+// RUN: %clang_cc1 -fms-extensions -std=c++11 %s -verify
+
+struct Nontemplate {
+  typedef int type;
+};
+
+template<typename T>
+struct X {
+  __if_exists(Nontemplate::type) {
+    typedef Nontemplate::type type;
+  }
+
+  __if_exists(Nontemplate::value) {
+    typedef Nontemplate::value type2;
+  }
+
+  __if_not_exists(Nontemplate::value) {
+    typedef int type3;
+  }
+
+  __if_exists(T::X) { // expected-warning{{dependent __if_exists declarations are ignored}}
+    typedef T::X type4;
+  }
+};
+
+X<int>::type i1;
+X<int>::type2 i2; // expected-error{{no type named 'type2' in 'X<int>'}}
+X<int>::type3 i3;
+X<int>::type4 i4; // expected-error{{no type named 'type4' in 'X<int>'}}
+
+struct HasFoo { 
+  void foo();
+};
+struct HasBar { 
+  void bar(int);
+  void bar(float);
+};
+
+template<typename T>
+void f(T t) {
+  __if_exists(T::foo) {
+    { }
+    t.foo();
+  }
+
+  __if_not_exists(T::bar) {
+    int *i = t; // expected-error{{no viable conversion from 'HasFoo' to 'int *'}}
+    { }
+  }
+
+  int array2[] = {
+    0, 
+    __if_exists(T::bar) {2, }// expected-warning{{dependent __if_exists declarations are ignored}}
+    3
+  };
+}
+
+template void f(HasFoo); // expected-note{{in instantiation of function template specialization 'f<HasFoo>' requested here}}
+template void f(HasBar);
+
+template<typename T, typename ...Ts>
+void g(T, Ts...) {
+  __if_exists(T::operator Ts) { // expected-error{{__if_exists name contains unexpanded parameter pack 'Ts'}}
+  }
+
+  __if_not_exists(Ts::operator T) { // expected-error{{__if_not_exists name contains unexpanded parameter pack 'Ts'}}
+  }
+}
diff --git a/clang/test/SemaTemplate/ms-lookup-template-base-classes.cpp b/clang/test/SemaTemplate/ms-lookup-template-base-classes.cpp
new file mode 100644
index 0000000..2c422dc
--- /dev/null
+++ b/clang/test/SemaTemplate/ms-lookup-template-base-classes.cpp
@@ -0,0 +1,145 @@
+// RUN: %clang_cc1 -fms-compatibility -fsyntax-only -verify %s
+
+
+template <class T>
+class A {
+public:
+   void f(T a) { }// expected-note {{must qualify identifier to find this declaration in dependent base class}}
+   void g();// expected-note {{must qualify identifier to find this declaration in dependent base class}}
+};
+
+
+template <class T>
+class B : public A<T> {
+public:
+	void z(T a)
+    {
+       f(a); // expected-warning {{use of identifier 'f' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+       g(); // expected-warning {{use of identifier 'g' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+    }
+};
+
+template class B<int>; // expected-note {{requested here}}
+template class B<char>;
+
+void test()
+{
+    B<int> b;
+    b.z(3);
+}
+
+namespace lookup_dependent_bases_id_expr {
+
+template<class T> class A {
+public:
+  int var;
+};
+
+
+template<class T>
+class B : public A<T> {
+public:
+  void f() {
+    var = 3;
+  }
+};
+
+template class B<int>;
+
+}
+
+
+
+namespace lookup_dependent_base_class_static_function {
+
+template <class T>
+class A {
+public:
+   static void static_func();// expected-note {{must qualify identifier to find this declaration in dependent base class}}
+   void func();// expected-note {{must qualify identifier to find this declaration in dependent base class}}
+};
+
+
+template <class T>
+class B : public A<T> {
+public:
+  static void z2(){
+    static_func();  // expected-warning {{use of identifier 'static_func' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+    func(); // expected-warning {{use of identifier 'func' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}} expected-error {{call to non-static member function without an object argument}}
+  }
+};
+template class B<int>; // expected-note {{requested here}}
+
+} 
+
+
+
+namespace lookup_dependent_base_class_default_argument {
+
+template<class T>
+class A {
+public:
+  static int f1(); // expected-note {{must qualify identifier to find this declaration in dependent base class}} 
+  int f2(); // expected-note {{must qualify identifier to find this declaration in dependent base class}} 
+};
+
+template<class T>
+class B : public A<T> {
+public:
+  void g1(int p = f1());// expected-warning {{use of identifier 'f1' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+  void g2(int p = f2());// expected-warning {{use of identifier 'f2' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}} expected-error {{call to non-static member function without an object argument}}
+};
+
+void foo()
+{
+	B<int> b;
+	b.g1(); // expected-note {{required here}}
+	b.g2(); // expected-note {{required here}}
+}
+
+}
+
+
+namespace lookup_dependent_base_class_friend {
+
+template <class T>
+class B {
+public:
+  static void g();  // expected-note {{must qualify identifier to find this declaration in dependent base class}} 
+};
+
+template <class T>
+class A : public B<T> {
+public:
+  friend void foo(A<T> p){
+    g(); // expected-warning {{use of identifier 'g' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+  }
+};
+
+int main2()
+{
+  A<int> a;
+  foo(a); // expected-note {{requested here}}
+}
+
+}
+
+
+namespace lookup_dependent_base_no_typo_correction {
+
+class C {
+public:
+  int m_hWnd;
+};
+
+template <class T>
+class A : public T {
+public:
+  void f(int hWnd) {
+    m_hWnd = 1;
+  }
+};
+
+template class A<C>;
+
+}
diff --git a/clang/test/SemaTemplate/nested-incomplete-class.cpp b/clang/test/SemaTemplate/nested-incomplete-class.cpp
new file mode 100644
index 0000000..a4bfccb
--- /dev/null
+++ b/clang/test/SemaTemplate/nested-incomplete-class.cpp
@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -fsyntax-only %s
+
+template <typename T>
+struct foo {
+  struct bar;
+
+  bar fn() {
+    // Should not get errors about bar being incomplete here.
+    bar b = bar(1, 2);
+    return b;
+  }
+};
+
+template <typename T>
+struct foo<T>::bar {
+  bar(int, int);
+};
+
+void fn() {
+  foo<int>().fn();
+}
diff --git a/clang/test/SemaTemplate/nested-linkage.cpp b/clang/test/SemaTemplate/nested-linkage.cpp
new file mode 100644
index 0000000..6c0791c
--- /dev/null
+++ b/clang/test/SemaTemplate/nested-linkage.cpp
@@ -0,0 +1,3 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+extern "C" { extern "C++" { template<class C> C x(); } }
diff --git a/clang/test/SemaTemplate/nested-name-spec-template.cpp b/clang/test/SemaTemplate/nested-name-spec-template.cpp
new file mode 100644
index 0000000..635687d
--- /dev/null
+++ b/clang/test/SemaTemplate/nested-name-spec-template.cpp
@@ -0,0 +1,142 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+namespace N { 
+  namespace M {
+    template<typename T> struct Promote;
+    
+    template<> struct Promote<short> {
+      typedef int type;
+    };
+    
+    template<> struct Promote<int> {
+      typedef int type;
+    };
+    
+    template<> struct Promote<float> {
+      typedef double type;
+    };
+    
+    Promote<short>::type *ret_intptr(int* ip) { return ip; }
+    Promote<int>::type *ret_intptr2(int* ip) { return ip; }
+  }
+
+  M::Promote<int>::type *ret_intptr3(int* ip) { return ip; }
+  M::template Promote<int>::type *ret_intptr4(int* ip) { return ip; } // expected-warning{{'template' keyword outside of a template}}
+  M::template Promote<int> pi; // expected-warning{{'template' keyword outside of a template}}
+}
+
+N::M::Promote<int>::type *ret_intptr5(int* ip) { return ip; }
+::N::M::Promote<int>::type *ret_intptr6(int* ip) { return ip; }
+
+
+N::M::template; // expected-error{{expected unqualified-id}}
+N::M::template Promote; // expected-error{{expected unqualified-id}}
+
+namespace N {
+  template<typename T> struct A;
+
+  template<>
+  struct A<int> {
+    struct X;
+  };
+
+  struct B;
+}
+
+struct ::N::A<int>::X {
+  int foo;
+};
+
+template<typename T>
+struct TestA {
+  typedef typename N::template B<T>::type type; // expected-error{{'B' following the 'template' keyword does not refer to a template}} \
+                                                // expected-error{{expected member name}}
+};
+
+// Reduced from a Boost failure.
+namespace test1 {
+  template <class T> struct pair {
+    T x;
+    T y;
+
+    static T pair<T>::* const mem_array[2];
+  };
+
+  template <class T>
+  T pair<T>::* const pair<T>::mem_array[2] = { &pair<T>::x, &pair<T>::y };
+}
+
+typedef int T;
+namespace N1 {
+  template<typename T> T f0();
+}
+
+template<typename T> T N1::f0() { }
+
+namespace PR7385 {
+  template< typename > struct has_xxx0
+  {
+    template< typename > struct has_xxx0_introspect
+    {
+      template< typename > struct has_xxx0_substitute ;
+      template< typename V > 
+      int int00( has_xxx0_substitute < typename V::template xxx< > > = 0 );
+    };
+    static const int value = has_xxx0_introspect<int>::value; // expected-error{{no member named 'value'}}
+    typedef int type;
+  };
+
+  has_xxx0<int>::type t; // expected-note{{instantiation of}}
+}
+
+namespace PR7725 {
+  template<class ignored> struct TypedefProvider;
+  template<typename T>
+  struct TemplateClass : public TypedefProvider<T>
+  {
+    void PrintSelf() {
+      TemplateClass::Test::PrintSelf();
+    }
+  };
+}
+
+namespace PR9226 {
+  template<typename a>
+  void nt() // expected-note{{function template 'nt' declared here}}
+  { nt<>:: } // expected-error{{qualified name refers into a specialization of function template 'nt'}} \
+  // expected-error{{expected unqualified-id}}
+
+  template<typename T>
+  void f(T*); // expected-note{{function template 'f' declared here}}
+
+  template<typename T>
+  void f(T*, T*); // expected-note{{function template 'f' declared here}}
+
+  void g() {
+    f<int>:: // expected-error{{qualified name refers into a specialization of function template 'f'}}
+  } // expected-error{{expected unqualified-id}}
+
+  struct X {
+    template<typename T> void f(); // expected-note{{function template 'f' declared here}}
+  };
+
+  template<typename T, typename U>
+  struct Y {
+    typedef typename T::template f<U> type; // expected-error{{template name refers to non-type template 'X::f'}}
+  };
+
+  Y<X, int> yxi; // expected-note{{in instantiation of template class 'PR9226::Y<PR9226::X, int>' requested here}}
+}
+
+namespace PR9449 {
+  template <typename T>
+  struct s; // expected-note{{template is declared here}}
+
+  template <typename T>
+  void f() {
+    int s<T>::template n<T>::* f; // expected-error{{implicit instantiation of undefined template 'PR9449::s<int>'}} \
+    // expected-error{{following the 'template' keyword}}
+  }
+
+  template void f<int>(); // expected-note{{in instantiation of}}
+}
diff --git a/clang/test/SemaTemplate/nested-template.cpp b/clang/test/SemaTemplate/nested-template.cpp
new file mode 100644
index 0000000..7849bae
--- /dev/null
+++ b/clang/test/SemaTemplate/nested-template.cpp
@@ -0,0 +1,157 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+class A;
+
+class S {
+public:
+   template<typename T> struct A { 
+     struct Nested {
+       typedef T type;
+     };
+   };
+};
+
+int i;
+S::A<int>::Nested::type *ip = &i;
+
+template<typename T>
+struct Outer {
+  template<typename U>
+  class Inner0;
+  
+  template<typename U>
+  class Inner1 {
+    struct ReallyInner;
+    
+    T foo(U);
+    template<typename V> T bar(V);
+    template<typename V> T* bar(V);
+    
+    static T value1;
+    static U value2;
+  };
+};
+
+template<typename X>
+template<typename Y>
+class Outer<X>::Inner0 {
+public:
+  void f(X, Y);
+};
+
+template<typename X>
+template<typename Y>
+void Outer<X>::Inner0<Y>::f(X, Y) {
+}
+
+template<typename X>
+template<typename Y>
+struct Outer<X>::Inner1<Y>::ReallyInner {
+  static Y value3;
+  
+  void g(X, Y);
+};
+
+template<typename X>
+template<typename Y>
+void Outer<X>::Inner1<Y>::ReallyInner::g(X, Y) {
+}
+
+template<typename X>
+template<typename Y>
+X Outer<X>::Inner1<Y>::foo(Y) {
+  return X();
+}
+
+template<typename X>
+template<typename Y>
+template<typename Z>
+X Outer<X>::Inner1<Y>::bar(Z) {
+  return X();
+}
+
+template<typename X>
+template<typename Y>
+template<typename Z>
+X* Outer<X>::Inner1<Y>::bar(Z) {
+  return 0;
+}
+
+template<typename X>
+template<typename Y>
+X Outer<X>::Inner1<Y>::value1 = 0;
+
+template<typename X>
+template<typename Y>
+Y Outer<X>::Inner1<Y>::value2 = Y();
+
+template<typename X>
+template<typename Y>
+Y Outer<X>::Inner1<Y>::ReallyInner::value3 = Y();
+
+template<typename X>
+template<typename Y>
+Y Outer<X>::Inner1<Y*>::ReallyInner::value4; // expected-error{{Outer<X>::Inner1<Y *>::ReallyInner::}}
+
+
+template<typename T>
+struct X0 { };
+
+template<typename T>
+struct X0<T*> {
+  template<typename U>
+  void f(U u = T()) { }
+};
+
+// PR5103
+template<typename>
+struct X1 {
+  template<typename, bool = false> struct B { };
+};
+template struct X1<int>::B<bool>;
+
+// Template template parameters
+template<typename T>
+struct X2 {
+  template<template<class U, T Value> class>  // expected-error{{cannot have type 'float'}} \
+                                              // expected-note{{previous non-type template}}
+    struct Inner { };
+};
+
+template<typename T, 
+         int Value> // expected-note{{template non-type parameter}}
+  struct X2_arg;
+
+X2<int>::Inner<X2_arg> x2i1;
+X2<float> x2a; // expected-note{{instantiation}}
+X2<long>::Inner<X2_arg> x2i3; // expected-error{{template template argument has different}}
+
+namespace PR10896 {
+  template<typename TN>
+  class Foo {
+
+  public:
+    void foo() {}
+  private:
+	
+    template<typename T>
+    T SomeField; // expected-error {{member 'SomeField' declared as a template}}
+  };
+
+  void g() {
+    Foo<int> f;
+    f.foo();
+  }
+}
+
+namespace PR10924 {
+  template< class Topology, class ctype >
+  struct ReferenceElement
+  {
+  };
+
+  template< class Topology, class ctype >
+  template< int codim >
+  class ReferenceElement< Topology, ctype > :: BaryCenterArray // expected-error{{out-of-line definition of 'BaryCenterArray' does not match any declaration in 'ReferenceElement<Topology, ctype>'}}
+  {
+  };
+}
diff --git a/clang/test/SemaTemplate/operator-function-id-template.cpp b/clang/test/SemaTemplate/operator-function-id-template.cpp
new file mode 100644
index 0000000..9a0884e
--- /dev/null
+++ b/clang/test/SemaTemplate/operator-function-id-template.cpp
@@ -0,0 +1,28 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T>
+struct A { 
+  template<typename U> A<T> operator+(U);
+};
+
+template<int Value, typename T> bool operator==(A<T>, A<T>);
+
+template<> bool operator==<0>(A<int>, A<int>);
+
+bool test_qualified_id(A<int> ai) {
+  return ::operator==<0, int>(ai, ai);
+}
+
+void test_op(A<int> a, int i) {
+  const A<int> &air = a.operator+<int>(i);
+}
+
+template<typename T>
+void test_op_template(A<T> at, T x) {
+  const A<T> &atr = at.template operator+<T>(x);
+  const A<T> &atr2 = at.A::template operator+<T>(x);
+  // FIXME: unrelated template-name instantiation issue
+  //  const A<T> &atr3 = at.template A<T>::template operator+<T>(x);
+}
+
+template void test_op_template<float>(A<float>, float);
diff --git a/clang/test/SemaTemplate/operator-template.cpp b/clang/test/SemaTemplate/operator-template.cpp
new file mode 100644
index 0000000..777b0f5
--- /dev/null
+++ b/clang/test/SemaTemplate/operator-template.cpp
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Make sure we accept this
+template<class X>struct A{typedef X Y;};
+template<class X>bool operator==(A<X>,typename A<X>::Y); // expected-note{{candidate template ignored: failed template argument deduction}}
+
+int a(A<int> x) { return operator==(x,1); }
+
+int a0(A<int> x) { return x == 1; }
+
+// FIXME: the location information for the note isn't very good
+template<class X>struct B{typedef X Y;};
+template<class X>bool operator==(B<X>*,typename B<X>::Y); // \
+// expected-error{{overloaded 'operator==' must have at least one parameter of class or enumeration type}} \
+// expected-note{{in instantiation of function template specialization}} \
+// expected-note{{candidate template ignored: substitution failure [with X = int]}}
+int a(B<int> x) { return operator==(&x,1); } // expected-error{{no matching function for call to 'operator=='}}
+
diff --git a/clang/test/SemaTemplate/overload-candidates.cpp b/clang/test/SemaTemplate/overload-candidates.cpp
new file mode 100644
index 0000000..8762cc8
--- /dev/null
+++ b/clang/test/SemaTemplate/overload-candidates.cpp
@@ -0,0 +1,40 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T>
+const T& min(const T&, const T&); // expected-note{{candidate template ignored: deduced conflicting types for parameter 'T' ('int' vs. 'long')}}
+
+void test_min() {
+  (void)min(1, 2l); // expected-error{{no matching function for call to 'min'}}
+}
+
+template<typename R, typename T>
+R *dyn_cast(const T&); // expected-note{{candidate template ignored: couldn't infer template argument 'R'}}
+
+void test_dyn_cast(int* ptr) {
+  (void)dyn_cast(ptr); // expected-error{{no matching function for call to 'dyn_cast'}}
+}
+
+template<int I, typename T> 
+  void get(const T&); // expected-note{{candidate template ignored: invalid explicitly-specified argument for template parameter 'I'}}
+template<template<class T> class, typename T> 
+  void get(const T&); // expected-note{{candidate template ignored: invalid explicitly-specified argument for 1st template parameter}}
+
+void test_get(void *ptr) {
+  get<int>(ptr); // expected-error{{no matching function for call to 'get'}}
+}
+
+template<typename T>
+  typename T::type get_type(const T&); // expected-note{{candidate template ignored: substitution failure [with T = int *]}}
+
+void test_get_type(int *ptr) {
+  (void)get_type(ptr); // expected-error{{no matching function for call to 'get_type'}}
+}
+
+struct X {
+  template<typename T>
+  const T& min(const T&, const T&); // expected-note{{candidate template ignored: deduced conflicting types for parameter 'T' ('int' vs. 'long')}}
+};
+
+void test_X_min(X x) {
+  (void)x.min(1, 2l); // expected-error{{no matching member function for call to 'min'}}
+}
diff --git a/clang/test/SemaTemplate/overload-uneval.cpp b/clang/test/SemaTemplate/overload-uneval.cpp
new file mode 100644
index 0000000..8d8a2f4
--- /dev/null
+++ b/clang/test/SemaTemplate/overload-uneval.cpp
@@ -0,0 +1,42 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-unused %s
+
+// Tests that overload resolution is treated as an unevaluated context.
+// PR5541
+struct Foo
+{
+    Foo *next;
+};
+
+template <typename>
+struct Bar
+{
+};
+
+
+template <typename T>
+class Wibble
+{
+    typedef Bar<T> B;
+
+    static inline B *concrete(Foo *node) {
+        int a[sizeof(T) ? -1 : -1];
+        return reinterpret_cast<B *>(node);
+    }
+
+public:
+    class It
+    {
+        Foo *i;
+
+    public:
+        inline operator B *() const { return concrete(i); }
+        inline bool operator!=(const It &o) const { return i !=
+o.i; }
+    };
+};
+
+void f() {
+  Wibble<void*>::It a, b;
+
+  a != b;
+}
diff --git a/clang/test/SemaTemplate/partial-spec-instantiate.cpp b/clang/test/SemaTemplate/partial-spec-instantiate.cpp
new file mode 100644
index 0000000..a93af50
--- /dev/null
+++ b/clang/test/SemaTemplate/partial-spec-instantiate.cpp
@@ -0,0 +1,50 @@
+// RUN: %clang_cc1 -fsyntax-only %s
+
+// PR4607
+template <class T> struct X {};
+
+template <> struct X<char>
+{
+  static char* g();
+};
+
+template <class T> struct X2 {};
+
+template <class U>
+struct X2<U*> {
+  static void f() {
+    X<U>::g();
+  }
+};
+
+void a(char *a, char *b) {X2<char*>::f();}
+
+namespace WonkyAccess {
+  template<typename T>
+  struct X {
+    int m;
+  };
+
+  template<typename U>
+  class Y;
+
+  template<typename U>
+  struct Y<U*> : X<U> { };
+
+  template<>
+  struct Y<float*> : X<float> { };
+
+  int f(Y<int*> y, Y<float*> y2) {
+    return y.m + y2.m;
+  }
+}
+
+// <rdar://problem/9169404>
+namespace rdar9169404 {
+  template<typename T, T N> struct X { };
+  template<bool C> struct X<bool, C> {
+    typedef int type;
+  };
+
+  X<bool, -1>::type value;
+}
diff --git a/clang/test/SemaTemplate/pragma-ms_struct.cpp b/clang/test/SemaTemplate/pragma-ms_struct.cpp
new file mode 100644
index 0000000..f04dc5c
--- /dev/null
+++ b/clang/test/SemaTemplate/pragma-ms_struct.cpp
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -triple i686-apple-osx10.7.0 %s
+
+#pragma ms_struct on
+
+// <rdar://problem/10791194>
+template<int x> struct foo {
+  long long a;
+  int b;
+};
+extern int arr[sizeof(foo<0>) == 16 ? 1 : -1];
diff --git a/clang/test/SemaTemplate/qualified-id.cpp b/clang/test/SemaTemplate/qualified-id.cpp
new file mode 100644
index 0000000..64dff1c
--- /dev/null
+++ b/clang/test/SemaTemplate/qualified-id.cpp
@@ -0,0 +1,56 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// PR5061
+namespace a {
+  template <typename T> class C {};
+}
+namespace b {
+  template<typename T> void f0(a::C<T> &a0) { }
+}
+
+
+namespace test1 {
+  int a = 0;
+  template <class T> class Base { };
+  template <class T> class Derived : public Base<T> {
+    int foo() {
+      return test1::a;
+    }
+  };
+}
+
+namespace test2 {
+  class Impl {
+  public:
+    int foo();
+  };
+  template <class T> class Magic : public Impl {
+    int foo() {
+      return Impl::foo();
+    }
+  };
+}
+
+namespace PR6063 {
+  template <typename T> void f(T, T);
+  
+  namespace detail 
+  {
+    using PR6063::f;
+  }
+  
+  template <typename T>
+  void g(T a, T b)
+  {
+    detail::f(a, b);
+  }
+}
+
+namespace PR12291 {
+  template <typename T>
+  class Outer2 {
+    template <typename V>
+    template <typename W>
+    class Outer2<V>::Inner; // expected-error{{nested name specifier 'Outer2<V>::' for declaration does not refer into a class, class template or class template partial specialization}}
+  };
+}
diff --git a/clang/test/SemaTemplate/qualified-names-diag.cpp b/clang/test/SemaTemplate/qualified-names-diag.cpp
new file mode 100644
index 0000000..b2df47b
--- /dev/null
+++ b/clang/test/SemaTemplate/qualified-names-diag.cpp
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+namespace std {
+  template<typename T> class vector { }; // expected-note{{candidate}}
+}
+
+typedef int INT;
+typedef float Real;
+
+void test() {
+  using namespace std;
+
+  std::vector<INT> v1;
+  vector<Real> v2;
+  v1 = v2; // expected-error{{no viable overloaded '='}}
+}
diff --git a/clang/test/SemaTemplate/rdar9173693.cpp b/clang/test/SemaTemplate/rdar9173693.cpp
new file mode 100644
index 0000000..86b4954
--- /dev/null
+++ b/clang/test/SemaTemplate/rdar9173693.cpp
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// <rdar://problem/9173693>
+template< bool C > struct assert { };
+template< bool > struct assert_arg_pred_impl { }; // expected-note 3 {{declared here}}
+template< typename Pred > assert<false> assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type ); // expected-error 5 {{}}
diff --git a/clang/test/SemaTemplate/recovery-crash.cpp b/clang/test/SemaTemplate/recovery-crash.cpp
new file mode 100644
index 0000000..0ed3258
--- /dev/null
+++ b/clang/test/SemaTemplate/recovery-crash.cpp
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// We don't expect a fix-it to be applied in this case. Clang used to crash
+// trying to recover while adding 'this->' before Work(x);
+
+template <typename> struct A {
+  static void Work(int);  // expected-note{{must qualify identifier}}
+};
+
+template <typename T> struct B : public A<T> {
+  template <typename T2> B(T2 x) {
+    Work(x);  // expected-error{{use of undeclared identifier}}
+  }
+};
+
+void Test() {
+  B<int> b(0);  // expected-note{{in instantiation of function template}}
+}
+
diff --git a/clang/test/SemaTemplate/recursive-template-instantiation.cpp b/clang/test/SemaTemplate/recursive-template-instantiation.cpp
new file mode 100644
index 0000000..d6a0b24
--- /dev/null
+++ b/clang/test/SemaTemplate/recursive-template-instantiation.cpp
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T> void f(T* t) { // expected-note{{failed template argument deduction}}
+  f(*t); // expected-error{{no matching function}}\
+         // expected-note 3{{requested here}}
+}
+
+void test_f(int ****p) {
+  f(p); // expected-note{{requested here}}
+}
diff --git a/clang/test/SemaTemplate/resolve-single-template-id.cpp b/clang/test/SemaTemplate/resolve-single-template-id.cpp
new file mode 100644
index 0000000..0c9bacc
--- /dev/null
+++ b/clang/test/SemaTemplate/resolve-single-template-id.cpp
@@ -0,0 +1,82 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
+namespace std {
+  class type_info {};
+}
+
+void one() { }
+void two() { } // expected-note 4{{possible target for call}}
+void two(int) { } // expected-note 4{{possible target for call}}
+
+template<class T> void twoT() { } // expected-note 5{{possible target for call}}
+template<class T> void twoT(int) { } // expected-note 5{{possible target for call}}
+
+template<class T> void oneT() { }
+template<class T, class U> void oneT(U) { }
+/*
+The target can be
+ an object or reference being initialized (8.5, 8.5.3),
+ the left side of an assignment (5.17),
+ a parameter of a function (5.2.2),
+ a parameter of a user-defined operator (13.5),
+ the return value of a function, operator function, or conversion (6.6.3),
+ an explicit type conversion (5.2.3, 5.2.9, 5.4), or
+ a non-type template-parameter (14.3.2)
+*/
+//#include <typeinfo>
+template<void (*p)(int)> struct test { };
+
+int main()
+{
+   one;         // expected-warning {{expression result unused}}
+   two;         // expected-error {{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
+   oneT<int>;  // expected-warning {{expression result unused}}
+   twoT<int>;  // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
+   typeid(oneT<int>); // expected-warning{{expression result unused}}
+  sizeof(oneT<int>); // expected-warning {{expression result unused}}
+  sizeof(twoT<int>); //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
+  decltype(oneT<int>)* fun = 0;
+  
+  *one;    // expected-warning {{expression result unused}}
+  *oneT<int>;   // expected-warning {{expression result unused}}
+  *two;  //expected-error {{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} expected-error {{indirection requires pointer operand}}
+  *twoT<int>; //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
+  !oneT<int>;  // expected-warning {{expression result unused}} expected-warning {{address of function 'oneT<int>' will always evaluate to 'true'}} expected-note {{prefix with the address-of operator to silence this warning}}
+  +oneT<int>;  // expected-warning {{expression result unused}}
+  -oneT<int>;  //expected-error {{invalid argument type}}
+  oneT<int> == 0;   // expected-warning {{equality comparison result unused}} \
+                    // expected-note {{use '=' to turn this equality comparison into an assignment}}
+  0 == oneT<int>;   // expected-warning {{equality comparison result unused}}
+  0 != oneT<int>;    // expected-warning {{inequality comparison result unused}}
+  (false ? one : oneT<int>);   // expected-warning {{expression result unused}}
+  void (*p1)(int); p1 = oneT<int>;
+  
+  int i = (int) (false ? (void (*)(int))twoT<int> : oneT<int>); //expected-error {{incompatible operand}}
+  (twoT<int>) == oneT<int>; //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}} {{cannot resolve overloaded function 'twoT' from context}}
+  bool b = oneT<int>; // expected-warning {{address of function 'oneT<int>' will always evaluate to 'true'}} expected-note {{prefix with the address-of operator to silence this warning}}
+  void (*p)() = oneT<int>;
+  test<oneT<int> > ti;
+  void (*u)(int) = oneT<int>;
+
+  b = (void (*)()) twoT<int>;
+  
+  one < one; //expected-warning {{self-comparison always evaluates to false}} \
+             //expected-warning {{expression result unused}}         
+
+  oneT<int> < oneT<int>;  //expected-warning {{self-comparison always evaluates to false}} \
+                          //expected-warning {{expression result unused}}
+
+  two < two; //expected-error 2 {{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} expected-error {{invalid operands to binary expression ('void' and 'void')}}
+  twoT<int> < twoT<int>; //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}} {{cannot resolve overloaded function 'twoT' from context}}
+  oneT<int> == 0;   // expected-warning {{equality comparison result unused}} \
+                    // expected-note {{use '=' to turn this equality comparison into an assignment}}
+
+}
+
+struct rdar9108698 {
+  template<typename> void f();
+};
+
+void test_rdar9108698(rdar9108698 x) {
+  x.f<int>; // expected-error{{reference to non-static member function must be called}}
+}
diff --git a/clang/test/SemaTemplate/self-comparison.cpp b/clang/test/SemaTemplate/self-comparison.cpp
new file mode 100644
index 0000000..50ab660
--- /dev/null
+++ b/clang/test/SemaTemplate/self-comparison.cpp
@@ -0,0 +1,48 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template <int A, int B> void foo() {
+  (void)(A == A); // expected-warning {{self-comparison always evaluates to true}}
+  (void)(A == B);
+}
+template <int A, int B> struct S1 {
+  void foo() {
+    (void)(A == A); // expected-warning {{self-comparison always evaluates to true}}
+    (void)(A == B);
+  }
+};
+
+template <int A, int B> struct S2 {
+  template <typename T> T foo() {
+    (void)(A == A); // expected-warning {{self-comparison always evaluates to true}}
+    (void)(A == B);
+  }
+};
+
+struct S3 {
+  template <int A, int B> void foo() {
+    (void)(A == A); // expected-warning {{self-comparison always evaluates to true}}
+    (void)(A == B);
+  }
+};
+
+template <int A> struct S4 {
+  template <int B> void foo() {
+    (void)(A == A); // expected-warning {{self-comparison always evaluates to true}}
+    (void)(A == B);
+  }
+};
+
+const int N = 42;
+template <int X> void foo2() {
+  (void)(X == N);
+  (void)(N == X);
+}
+
+void test() {
+  foo<1, 1>();
+  S1<1, 1> s1; s1.foo();
+  S2<1, 1> s2; s2.foo<void>();
+  S3 s3; s3.foo<1, 1>();
+  S4<1> s4; s4.foo<1>();
+  foo2<N>();
+}
diff --git a/clang/test/SemaTemplate/temp.cpp b/clang/test/SemaTemplate/temp.cpp
new file mode 100644
index 0000000..e037f0f
--- /dev/null
+++ b/clang/test/SemaTemplate/temp.cpp
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+
+namespace test0 {
+  // p3
+  template<typename T> int foo(T), bar(T, T); // expected-error{{single entity}}
+}
+
+// PR7252
+namespace test1 {
+  namespace A { template<typename T> struct Base { typedef T t; }; } // expected-note {{member found}}
+  namespace B { template<typename T> struct Base { typedef T t; }; } // expected-note {{member found}}
+
+  template<typename T> struct Derived : A::Base<char>, B::Base<int> {
+    // FIXME: the syntax error here is unfortunate
+    typename Derived::Base<float>::t x; // expected-error {{found in multiple base classes of different types}} \
+                                        // expected-error {{expected member name or ';'}}
+  };
+}
diff --git a/clang/test/SemaTemplate/temp_arg.cpp b/clang/test/SemaTemplate/temp_arg.cpp
new file mode 100644
index 0000000..5a4c8fc
--- /dev/null
+++ b/clang/test/SemaTemplate/temp_arg.cpp
@@ -0,0 +1,20 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T, 
+         int I, 
+         template<typename> class TT>
+  class A; // expected-note 3 {{template is declared here}}
+
+template<typename> class X;
+
+A<int, 0, X> * a1;
+
+A<float, 1, X, double> *a2; // expected-error{{too many template arguments for class template 'A'}}
+A<float, 1> *a3; // expected-error{{too few template arguments for class template 'A'}}
+A a3; // expected-error{{use of class template A requires template arguments}}
+
+namespace test0 {
+  template <class t> class foo {};
+  template <class t> class bar {
+    bar(::test0::foo<tee> *ptr) {} // FIXME(redundant): expected-error 2 {{use of undeclared identifier 'tee'}}
+  };
+}
diff --git a/clang/test/SemaTemplate/temp_arg_nontype.cpp b/clang/test/SemaTemplate/temp_arg_nontype.cpp
new file mode 100644
index 0000000..747ddcc
--- /dev/null
+++ b/clang/test/SemaTemplate/temp_arg_nontype.cpp
@@ -0,0 +1,325 @@
+// RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wconversion -verify %s
+template<int N> struct A; // expected-note 5{{template parameter is declared here}}
+
+A<0> *a0;
+
+A<int()> *a1; // expected-error{{template argument for non-type template parameter is treated as type 'int ()'}}
+
+A<int> *a2; // expected-error{{template argument for non-type template parameter must be an expression}}
+
+A<1 >> 2> *a3; // expected-warning{{use of right-shift operator ('>>') in template argument will require parentheses in C++11}}
+
+// C++ [temp.arg.nontype]p5:
+A<A> *a4; // expected-error{{must be an expression}}
+
+enum E { Enumerator = 17 };
+A<E> *a5; // expected-error{{template argument for non-type template parameter must be an expression}}
+template<E Value> struct A1; // expected-note{{template parameter is declared here}}
+A1<Enumerator> *a6; // okay
+A1<17> *a7; // expected-error{{non-type template argument of type 'int' cannot be converted to a value of type 'E'}}
+
+const long LongValue = 12345678;
+A<LongValue> *a8;
+const short ShortValue = 17;
+A<ShortValue> *a9;
+
+int f(int);
+A<f(17)> *a10; // expected-error{{non-type template argument of type 'int' is not an integral constant expression}}
+
+class X {
+public:
+  X();
+  X(int, int);
+  operator int() const;
+};
+A<X(17, 42)> *a11; // expected-error{{non-type template argument of type 'X' must have an integral or enumeration type}}
+
+float f(float);
+
+float g(float); // expected-note 2{{candidate function}}
+double g(double); // expected-note 2{{candidate function}}
+
+int h(int);
+float h2(float);
+
+template<int fp(int)> struct A3; // expected-note 1{{template parameter is declared here}}
+A3<h> *a14_1;
+A3<&h> *a14_2;
+A3<f> *a14_3;
+A3<&f> *a14_4;
+A3<h2> *a14_6;  // expected-error{{non-type template argument of type 'float (float)' cannot be converted to a value of type 'int (*)(int)'}}
+A3<g> *a14_7; // expected-error{{address of overloaded function 'g' does not match required type 'int (int)'}}
+
+
+struct Y { } y;
+
+volatile X * X_volatile_ptr;
+template<X const &AnX> struct A4; // expected-note 2{{template parameter is declared here}}
+X an_X;
+A4<an_X> *a15_1; // okay
+A4<*X_volatile_ptr> *a15_2; // expected-error{{non-type template argument does not refer to any declaration}}
+A4<y> *15_3; //  expected-error{{non-type template parameter of reference type 'const X &' cannot bind to template argument of type 'struct Y'}} \
+            // FIXME: expected-error{{expected unqualified-id}}
+
+template<int (&fr)(int)> struct A5; // expected-note{{template parameter is declared here}}
+A5<h> *a16_1;
+A5<f> *a16_3;
+A5<h2> *a16_6;  // expected-error{{non-type template parameter of reference type 'int (&)(int)' cannot bind to template argument of type 'float (float)'}}
+A5<g> *a14_7; // expected-error{{address of overloaded function 'g' does not match required type 'int (int)'}}
+
+struct Z {
+  int foo(int);
+  float bar(float);
+  int bar(int);
+  double baz(double);
+
+  int int_member;
+  float float_member;
+};
+template<int (Z::*pmf)(int)> struct A6; // expected-note{{template parameter is declared here}}
+A6<&Z::foo> *a17_1;
+A6<&Z::bar> *a17_2;
+A6<&Z::baz> *a17_3; // expected-error{{non-type template argument of type 'double (Z::*)(double)' cannot be converted to a value of type 'int (Z::*)(int)'}}
+
+
+template<int Z::*pm> struct A7;  // expected-note{{template parameter is declared here}}
+template<int Z::*pm> struct A7c;
+A7<&Z::int_member> *a18_1;
+A7c<&Z::int_member> *a18_2;
+A7<&Z::float_member> *a18_3; // expected-error{{non-type template argument of type 'float Z::*' cannot be converted to a value of type 'int Z::*'}}
+A7c<(&Z::int_member)> *a18_4; // expected-warning{{address non-type template argument cannot be surrounded by parentheses}}
+
+template<unsigned char C> struct Overflow; // expected-note{{template parameter is declared here}}
+
+Overflow<5> *overflow1; // okay
+Overflow<255> *overflow2; // okay
+Overflow<256> *overflow3; // expected-warning{{non-type template argument value '256' truncated to '0' for template parameter of type 'unsigned char'}}
+
+
+template<unsigned> struct Signedness; // expected-note{{template parameter is declared here}}
+Signedness<10> *signedness1; // okay
+Signedness<-10> *signedness2; // expected-warning{{non-type template argument with value '-10' converted to '4294967286' for unsigned template parameter of type 'unsigned int'}}
+
+template<signed char C> struct SignedOverflow; // expected-note 3 {{template parameter is declared here}}
+SignedOverflow<1> *signedoverflow1;
+SignedOverflow<-1> *signedoverflow2;
+SignedOverflow<-128> *signedoverflow3;
+SignedOverflow<-129> *signedoverflow4; // expected-warning{{non-type template argument value '-129' truncated to '127' for template parameter of type 'signed char'}}
+SignedOverflow<127> *signedoverflow5;
+SignedOverflow<128> *signedoverflow6; // expected-warning{{non-type template argument value '128' truncated to '-128' for template parameter of type 'signed char'}}
+SignedOverflow<(unsigned char)128> *signedoverflow7; // expected-warning{{non-type template argument value '128' truncated to '-128' for template parameter of type 'signed char'}}
+
+// Check canonicalization of template arguments.
+template<int (*)(int, int)> struct FuncPtr0;
+int func0(int, int);
+extern FuncPtr0<&func0> *fp0;
+template<int (*)(int, int)> struct FuncPtr0;
+extern FuncPtr0<&func0> *fp0;
+int func0(int, int);
+extern FuncPtr0<&func0> *fp0;
+
+// PR5350
+namespace ns {
+  template <typename T>
+  struct Foo {
+    static const bool value = true;
+  };
+  
+  template <bool b>
+  struct Bar {};
+  
+  const bool value = false;
+  
+  Bar<bool(ns::Foo<int>::value)> x;
+}
+
+// PR5349
+namespace ns {
+  enum E { k };
+  
+  template <E e>
+  struct Baz  {};
+  
+  Baz<k> f1;  // This works.
+  Baz<E(0)> f2;  // This too.
+  Baz<static_cast<E>(0)> f3;  // And this.
+  
+  Baz<ns::E(0)> b1;  // This doesn't work.
+  Baz<static_cast<ns::E>(0)> b2;  // This neither.  
+}
+
+// PR5597
+template<int (*)(float)> struct X0 { };
+
+struct X1 {
+    static int pfunc(float);
+};
+void test_X0_X1() {
+  X0<X1::pfunc> x01;
+}
+
+// PR6249
+namespace pr6249 {
+  template<typename T, T (*func)()> T f() {
+    return func();
+  }
+
+  int h();
+  template int f<int, h>();
+}
+
+namespace PR6723 {
+  template<unsigned char C> void f(int (&a)[C]); // expected-note {{candidate template ignored}} \
+  // expected-note{{substitution failure [with C = '\x00']}}
+  void g() {
+    int arr512[512];
+    f(arr512); // expected-error{{no matching function for call}}
+    f<512>(arr512); // expected-error{{no matching function for call}}
+  }
+}
+
+// Check that we instantiate declarations whose addresses are taken
+// for non-type template arguments.
+namespace EntityReferenced {
+  template<typename T, void (*)(T)> struct X { };
+
+  template<typename T>
+  struct Y {
+    static void f(T x) { 
+      x = 1; // expected-error{{assigning to 'int *' from incompatible type 'int'}}
+    }
+  };
+
+  void g() {
+    typedef X<int*, Y<int*>::f> x; // expected-note{{in instantiation of}}
+  }
+}
+
+namespace PR6964 {
+  template <typename ,int, int = 9223372036854775807L > // expected-warning 2{{non-type template argument value '9223372036854775807' truncated to '-1' for template parameter of type 'int'}} \
+  // expected-note 2{{template parameter is declared here}}
+  struct as_nview { };
+
+  template <typename Sequence, int I0> 
+  struct as_nview<Sequence, I0>  // expected-note{{while checking a default template argument used here}}
+  { };
+}
+
+// rdar://problem/8302138
+namespace test8 {
+  template <int* ip> struct A {
+    int* p;
+    A() : p(ip) {}
+  };
+
+  void test0() {
+    extern int i00;
+    A<&i00> a00;
+  }
+
+  extern int i01;
+  void test1() {
+    A<&i01> a01;
+  }
+
+
+  struct C {
+    int x;
+    char y;
+    double z;
+  };
+  
+  template <C* cp> struct B {
+    C* p;
+    B() : p(cp) {}
+  };
+
+  void test2() {
+    extern C c02;
+    B<&c02> b02;
+  }
+
+  extern C c03;
+  void test3() {
+    B<&c03> b03;
+  }
+}
+
+namespace PR8372 {
+  template <int I> void foo() { } // expected-note{{template parameter is declared here}}
+  void bar() { foo <0x80000000> (); } // expected-warning{{non-type template argument value '2147483648' truncated to '-2147483648' for template parameter of type 'int'}}
+}
+
+namespace PR9227 {
+  template <bool B> struct enable_if_bool { };
+  template <> struct enable_if_bool<true> { typedef int type; };
+  void test_bool() { enable_if_bool<false>::type i; } // expected-error{{enable_if_bool<false>}}
+
+  template <char C> struct enable_if_char { };
+  template <> struct enable_if_char<'a'> { typedef int type; };
+  void test_char_0() { enable_if_char<0>::type i; } // expected-error{{enable_if_char<'\x00'>}}
+  void test_char_b() { enable_if_char<'b'>::type i; } // expected-error{{enable_if_char<'b'>}}
+  void test_char_possibly_negative() { enable_if_char<'\x02'>::type i; } // expected-error{{enable_if_char<'\x02'>}}
+  void test_char_single_quote() { enable_if_char<'\''>::type i; } // expected-error{{enable_if_char<'\''>}}
+  void test_char_backslash() { enable_if_char<'\\'>::type i; } // expected-error{{enable_if_char<'\\'>}}
+}
+
+namespace PR10579 {
+  namespace fcppt
+  {
+    namespace container
+    {
+      namespace bitfield
+      {
+
+        template<
+          typename Enum,
+          Enum Size
+          >
+        class basic;
+
+        template<
+          typename Enum,
+          Enum Size
+          >
+        class basic
+        {
+        public:
+          basic()
+          {
+          }
+        };
+
+      }
+    }
+  }
+
+  namespace
+  {
+
+    namespace testenum
+    {
+      enum type
+        {
+          foo,
+          bar,
+          size
+        };
+    }
+
+  }
+
+  int main()
+  {
+    typedef fcppt::container::bitfield::basic<
+    testenum::type,
+      testenum::size
+      > bitfield_foo;
+
+    bitfield_foo obj;
+  }
+
+}
+
+template <int& I> struct PR10766 { static int *ip; };
+template <int& I> int* PR10766<I>::ip = &I;
diff --git a/clang/test/SemaTemplate/temp_arg_template.cpp b/clang/test/SemaTemplate/temp_arg_template.cpp
new file mode 100644
index 0000000..c9ce1b6
--- /dev/null
+++ b/clang/test/SemaTemplate/temp_arg_template.cpp
@@ -0,0 +1,62 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<template<typename T> class X> struct A; // expected-note 2{{previous template template parameter is here}}
+
+template<template<typename T, int I> class X> struct B; // expected-note{{previous template template parameter is here}}
+
+template<template<int I> class X> struct C;  // expected-note{{previous non-type template parameter with type 'int' is here}}
+
+template<class> struct X; // expected-note{{too few template parameters in template template argument}}
+template<int N> struct Y; // expected-note{{template parameter has a different kind in template argument}}
+template<long N> struct Ylong; // expected-note{{template non-type parameter has a different type 'long' in template argument}}
+
+namespace N {
+  template<class> struct Z;
+}
+template<class, class> struct TooMany; // expected-note{{too many template parameters in template template argument}}
+
+
+A<X> *a1; 
+A<N::Z> *a2;
+A< ::N::Z> *a3;
+
+A<Y> *a4; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
+A<TooMany> *a5; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
+B<X> *a6; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
+C<Y> *a7;
+C<Ylong> *a8; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
+
+template<typename T> void f(int);
+
+A<f> *a9; // expected-error{{must be a class template}}
+
+// Evil digraph '<:' is parsed as '[', expect error.
+A<::N::Z> *a10; // expected-error{{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
+
+// Do not do a digraph correction here.
+A<: :N::Z> *a11;  // expected-error{{expected expression}} \
+          expected-error{{C++ requires a type specifier for all declarations}}
+
+// PR7807
+namespace N {
+  template <typename, typename = int> 
+  struct X
+  { };
+
+  template <typename ,int> 
+  struct Y
+  { X<int> const_ref(); };
+
+  template <template<typename,int> class TT, typename T, int N> 
+  int operator<<(int, TT<T, N> a) { // expected-note{{candidate template ignored}}
+    0 << a.const_ref(); // expected-error{{invalid operands to binary expression ('int' and 'X<int>')}}
+  }
+
+  void f0( Y<int,1> y){ 1 << y; } // expected-note{{in instantiation of function template specialization 'N::operator<<<Y, int, 1>' requested here}}
+}
+
+// PR12179
+template <typename Primitive, template <Primitive...> class F> // expected-warning {{variadic templates are a C++11 extension}}
+struct unbox_args {
+  typedef typename Primitive::template call<F> x;
+};
diff --git a/clang/test/SemaTemplate/temp_arg_type.cpp b/clang/test/SemaTemplate/temp_arg_type.cpp
new file mode 100644
index 0000000..3970942
--- /dev/null
+++ b/clang/test/SemaTemplate/temp_arg_type.cpp
@@ -0,0 +1,42 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T> class A; // expected-note 2 {{template parameter is declared here}} expected-note{{template is declared here}}
+
+// [temp.arg.type]p1
+A<0> *a1; // expected-error{{template argument for template type parameter must be a type}}
+
+A<A> *a2; // expected-error{{use of class template A requires template arguments}}
+
+A<int> *a3;
+A<int()> *a4; 
+A<int(float)> *a5;
+A<A<int> > *a6;
+
+// Pass an overloaded function template:
+template<typename T> void function_tpl(T);
+A<function_tpl> a7;  // expected-error{{template argument for template type parameter must be a type}}
+
+// Pass a qualified name:
+namespace ns {
+template<typename T> class B {};  // expected-note{{template is declared here}}
+}
+A<ns::B> a8; // expected-error{{use of class template ns::B requires template arguments}}
+
+// [temp.arg.type]p2
+void f() {
+  class X { };
+  A<X> * a = 0; // expected-warning{{template argument uses local type 'X'}}
+}
+
+struct { int x; } Unnamed; // expected-note{{unnamed type used in template argument was declared here}}
+A<__typeof__(Unnamed)> *a9; // expected-warning{{template argument uses unnamed type}}
+
+template<typename T, unsigned N>
+struct Array {
+  typedef struct { T x[N]; } type;
+};
+
+template<typename T> struct A1 { };
+A1<Array<int, 17>::type> ax;
+
+// FIXME: [temp.arg.type]p3. The check doesn't really belong here (it
+// belongs somewhere in the template instantiation section).
diff --git a/clang/test/SemaTemplate/temp_class_order.cpp b/clang/test/SemaTemplate/temp_class_order.cpp
new file mode 100644
index 0000000..fcf0325
--- /dev/null
+++ b/clang/test/SemaTemplate/temp_class_order.cpp
@@ -0,0 +1,42 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T, typename U>
+struct X1 {
+  static const int value = 0;
+};
+
+template<typename T, typename U>
+struct X1<T*, U*> {
+  static const int value = 1;
+};
+
+template<typename T>
+struct X1<T*, T*> {
+  static const int value = 2;
+};
+
+template<typename T>
+struct X1<const T*, const T*> {
+  static const int value = 3;
+};
+
+int array0[X1<int, int>::value == 0? 1 : -1];
+int array1[X1<int*, float*>::value == 1? 1 : -1];
+int array2[X1<int*, int*>::value == 2? 1 : -1];
+typedef const int* CIP;
+int array3[X1<const int*, CIP>::value == 3? 1 : -1];
+
+template<typename T, typename U>
+struct X2 { };
+
+template<typename T, typename U>
+struct X2<T*, U> { }; // expected-note{{matches}}
+
+template<typename T, typename U>
+struct X2<T, U*> { }; // expected-note{{matches}}
+
+template<typename T, typename U>
+struct X2<const T*, const U*> { };
+
+X2<int*, int*> x2a; // expected-error{{ambiguous}}
+X2<const int*, const int*> x2b;
diff --git a/clang/test/SemaTemplate/temp_class_spec.cpp b/clang/test/SemaTemplate/temp_class_spec.cpp
new file mode 100644
index 0000000..8a07fd7
--- /dev/null
+++ b/clang/test/SemaTemplate/temp_class_spec.cpp
@@ -0,0 +1,363 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T>
+struct is_pointer {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_pointer<T*> {
+  static const bool value = true;
+};
+
+template<typename T>
+struct is_pointer<const T*> {
+  static const bool value = true;
+};
+
+int array0[is_pointer<int>::value? -1 : 1];
+int array1[is_pointer<int*>::value? 1 : -1];
+int array2[is_pointer<const int*>::value? 1 : -1];
+
+template<typename T>
+struct is_lvalue_reference {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_lvalue_reference<T&> {
+  static const bool value = true;
+};
+
+int lvalue_ref0[is_lvalue_reference<int>::value? -1 : 1];
+int lvalue_ref1[is_lvalue_reference<const int&>::value? 1 : -1];
+
+template<typename T>
+struct is_const {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_const<const T> {
+  static const bool value = true;
+};
+
+int is_const0[is_const<int>::value? -1 : 1];
+int is_const1[is_const<const int>::value? 1 : -1];
+int is_const2[is_const<const volatile int>::value? 1 : -1];
+int is_const3[is_const<const int [3]>::value? 1 : -1];
+int is_const4[is_const<const volatile int[3]>::value? 1 : -1];
+int is_const5[is_const<volatile int[3]>::value? -1 : 1];
+
+template<typename T>
+struct is_volatile {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_volatile<volatile T> {
+  static const bool value = true;
+};
+
+int is_volatile0[is_volatile<int>::value? -1 : 1];
+int is_volatile1[is_volatile<volatile int>::value? 1 : -1];
+int is_volatile2[is_volatile<const volatile int>::value? 1 : -1];
+int is_volatile3[is_volatile<volatile char[3]>::value? 1 : -1];
+                 
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+typedef int INT;
+typedef INT* int_ptr;
+
+int is_same0[is_same<int, int>::value? 1 : -1];
+int is_same1[is_same<int, INT>::value? 1 : -1];
+int is_same2[is_same<const int, int>::value? -1 : 1];
+int is_same3[is_same<int_ptr, int>::value? -1 : 1];
+
+template<typename T>
+struct remove_reference {
+  typedef T type;
+};
+
+template<typename T>
+struct remove_reference<T&> {
+  typedef T type;
+};
+
+int remove_ref0[is_same<remove_reference<int>::type, int>::value? 1 : -1];
+int remove_ref1[is_same<remove_reference<int&>::type, int>::value? 1 : -1];
+
+template<typename T>
+struct remove_const {
+  typedef T type;
+};
+
+template<typename T>
+struct remove_const<const T> {
+  typedef T type;
+};
+
+int remove_const0[is_same<remove_const<const int>::type, int>::value? 1 : -1];
+int remove_const1[is_same<remove_const<const int[3]>::type, int[3]>::value? 1 : -1];
+
+template<typename T>
+struct is_incomplete_array {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_incomplete_array<T[]> {
+  static const bool value = true;
+};
+
+int incomplete_array0[is_incomplete_array<int>::value ? -1 : 1];
+int incomplete_array1[is_incomplete_array<int[1]>::value ? -1 : 1];
+int incomplete_array2[is_incomplete_array<bool[]>::value ? 1 : -1];
+int incomplete_array3[is_incomplete_array<int[]>::value ? 1 : -1];
+
+template<typename T>
+struct is_array_with_4_elements {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_array_with_4_elements<T[4]> {
+  static const bool value = true;
+};
+
+int array_with_4_elements0[is_array_with_4_elements<int[]>::value ? -1 : 1];
+int array_with_4_elements1[is_array_with_4_elements<int[1]>::value ? -1 : 1];
+int array_with_4_elements2[is_array_with_4_elements<int[4]>::value ? 1 : -1];
+int array_with_4_elements3[is_array_with_4_elements<int[4][2]>::value ? 1 : -1];
+
+template<typename T>
+struct get_array_size;
+
+template<typename T, unsigned N>
+struct get_array_size<T[N]> {
+  static const unsigned value = N;
+};
+
+int array_size0[get_array_size<int[12]>::value == 12? 1 : -1];
+
+template<typename T>
+struct remove_extent {
+  typedef T type;
+};
+
+template<typename T>
+struct remove_extent<T[]> { 
+  typedef T type;
+};
+
+template<typename T, unsigned N>
+struct remove_extent<T[N]> { 
+  typedef T type;
+};
+
+int remove_extent0[is_same<remove_extent<int[][5]>::type, int[5]>::value? 1 : -1];
+int remove_extent1[is_same<remove_extent<const int[][5]>::type, const int[5]>::value? 1 : -1];
+
+template<typename T>
+struct is_unary_function {
+  static const bool value = false;
+};
+
+template<typename T, typename U>
+struct is_unary_function<T (*)(U)> {
+  static const bool value = true;
+};
+
+int is_unary_function0[is_unary_function<int>::value ? -1 : 1];
+int is_unary_function1[is_unary_function<int (*)()>::value ? -1 : 1];
+int is_unary_function2[is_unary_function<int (*)(int, bool)>::value ? -1 : 1];
+int is_unary_function3[is_unary_function<int (*)(bool)>::value ? 1 : -1];
+int is_unary_function4[is_unary_function<int (*)(int)>::value ? 1 : -1];
+
+template<typename T>
+struct is_unary_function_with_same_return_type_as_argument_type {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_unary_function_with_same_return_type_as_argument_type<T (*)(T)> {
+  static const bool value = true;
+};
+
+int is_unary_function5[is_unary_function_with_same_return_type_as_argument_type<int>::value ? -1 : 1];
+int is_unary_function6[is_unary_function_with_same_return_type_as_argument_type<int (*)()>::value ? -1 : 1];
+int is_unary_function7[is_unary_function_with_same_return_type_as_argument_type<int (*)(int, bool)>::value ? -1 : 1];
+int is_unary_function8[is_unary_function_with_same_return_type_as_argument_type<int (*)(bool)>::value ? -1 : 1];
+int is_unary_function9[is_unary_function_with_same_return_type_as_argument_type<int (*)(int)>::value ? 1 : -1];
+int is_unary_function10[is_unary_function_with_same_return_type_as_argument_type<int (*)(int, ...)>::value ? -1 : 1];
+int is_unary_function11[is_unary_function_with_same_return_type_as_argument_type<int (* const)(int)>::value ? -1 : 1];
+
+template<typename T>
+struct is_binary_function {
+  static const bool value = false;
+};
+
+template<typename R, typename T1, typename T2>
+struct is_binary_function<R(T1, T2)> {
+  static const bool value = true;
+};
+
+int is_binary_function0[is_binary_function<int(float, double)>::value? 1 : -1];
+
+template<typename T>
+struct is_member_pointer {
+  static const bool value = false;
+};
+
+template<typename T, typename Class>
+struct is_member_pointer<T Class::*> {
+  static const bool value = true;
+};
+
+struct X { };
+
+int is_member_pointer0[is_member_pointer<int X::*>::value? 1 : -1];
+int is_member_pointer1[is_member_pointer<const int X::*>::value? 1 : -1];
+int is_member_pointer2[is_member_pointer<int (X::*)()>::value? 1 : -1];
+int is_member_pointer3[is_member_pointer<int (X::*)(int) const>::value? 1 : -1];
+int is_member_pointer4[is_member_pointer<int (X::**)(int) const>::value? -1 : 1];
+int is_member_pointer5[is_member_pointer<int>::value? -1 : 1];
+
+template<typename T>
+struct is_member_function_pointer {
+  static const bool value = false;
+};
+
+template<typename T, typename Class>
+struct is_member_function_pointer<T (Class::*)()> {
+  static const bool value = true;
+};
+
+template<typename T, typename Class>
+struct is_member_function_pointer<T (Class::*)() const> {
+  static const bool value = true;
+};
+
+template<typename T, typename Class>
+struct is_member_function_pointer<T (Class::*)() volatile> {
+  static const bool value = true;
+};
+
+template<typename T, typename Class>
+struct is_member_function_pointer<T (Class::*)() const volatile> {
+  static const bool value = true;
+};
+
+template<typename T, typename Class, typename A1>
+struct is_member_function_pointer<T (Class::*)(A1)> {
+  static const bool value = true;
+};
+
+template<typename T, typename Class, typename A1>
+struct is_member_function_pointer<T (Class::*)(A1) const> {
+  static const bool value = true;
+};
+
+template<typename T, typename Class, typename A1>
+struct is_member_function_pointer<T (Class::*)(A1) volatile> {
+  static const bool value = true;
+};
+
+template<typename T, typename Class, typename A1>
+struct is_member_function_pointer<T (Class::*)(A1) const volatile> {
+  static const bool value = true;
+};
+
+int is_member_function_pointer0[
+                          is_member_function_pointer<int X::*>::value? -1 : 1];
+int is_member_function_pointer1[
+                      is_member_function_pointer<int (X::*)()>::value? 1 : -1];
+int is_member_function_pointer2[
+                      is_member_function_pointer<X (X::*)(X&)>::value? 1 : -1];
+int is_member_function_pointer3[
+           is_member_function_pointer<int (X::*)() const>::value? 1 : -1];
+int is_member_function_pointer4[
+           is_member_function_pointer<int (X::*)(float) const>::value? 1 : -1];
+
+// Test substitution of non-dependent arguments back into the template
+// argument list of the class template partial specialization.
+template<typename T, typename ValueType = T>
+struct is_nested_value_type_identity {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_nested_value_type_identity<T, typename T::value_type> {
+  static const bool value = true;
+};
+
+template<typename T>
+struct HasValueType {
+  typedef T value_type;
+};
+
+struct HasIdentityValueType {
+  typedef HasIdentityValueType value_type;
+};
+
+struct NoValueType { };
+
+int is_nested_value_type_identity0[
+            is_nested_value_type_identity<HasValueType<int> >::value? -1 : 1];
+int is_nested_value_type_identity1[
+          is_nested_value_type_identity<HasIdentityValueType>::value? 1 : -1];
+int is_nested_value_type_identity2[
+                   is_nested_value_type_identity<NoValueType>::value? -1 : 1];
+
+
+// C++ [temp.class.spec]p4:
+template<class T1, class T2, int I> class A { }; //#1 
+template<class T, int I> class A<T, T*, I> { }; //#2 
+template<class T1, class T2, int I> class A<T1*, T2, I> { }; //#3 
+template<class T> class A<int, T*, 5> { }; //#4 
+template<class T1, class T2, int I> class A<T1, T2*, I> { }; //#5 
+
+// Redefinition of class template partial specializations
+template<typename T, T N, typename U> class A0;
+
+template<typename T, T N> class A0<T, N, int> { }; // expected-note{{here}}
+template<typename T, T N> class A0<T, N, int>;
+template<typename T, T N> class A0<T, N, int> { }; // expected-error{{redef}}
+
+namespace PR6025 {
+  template< int N > struct A;
+
+  namespace N 
+  {
+    template< typename F > 
+    struct B;
+  }
+
+  template< typename Protect, typename Second > 
+  struct C;
+
+  template <class T>
+  struct C< T, A< N::B<T>::value > >
+  {
+  };
+}
+
+namespace PR6181 {
+  template <class T>
+  class a;
+  
+  class s;
+  
+  template <class U>
+  class a<s> // expected-error{{partial specialization of 'a' does not use any of its template parameters}}
+  {
+  };
+  
+}
diff --git a/clang/test/SemaTemplate/temp_class_spec_blocks.cpp b/clang/test/SemaTemplate/temp_class_spec_blocks.cpp
new file mode 100644
index 0000000..b7b96df
--- /dev/null
+++ b/clang/test/SemaTemplate/temp_class_spec_blocks.cpp
@@ -0,0 +1,34 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s -fblocks
+template<typename T>
+struct is_unary_block {
+  static const bool value = false;
+};
+
+template<typename T, typename U>
+struct is_unary_block<T (^)(U)> {
+  static const bool value = true;
+};
+
+int is_unary_block0[is_unary_block<int>::value ? -1 : 1];
+int is_unary_block1[is_unary_block<int (^)()>::value ? -1 : 1];
+int is_unary_block2[is_unary_block<int (^)(int, bool)>::value ? -1 : 1];
+int is_unary_block3[is_unary_block<int (^)(bool)>::value ? 1 : -1];
+int is_unary_block4[is_unary_block<int (^)(int)>::value ? 1 : -1];
+
+template<typename T>
+struct is_unary_block_with_same_return_type_as_argument_type {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_unary_block_with_same_return_type_as_argument_type<T (^)(T)> {
+  static const bool value = true;
+};
+
+int is_unary_block5[is_unary_block_with_same_return_type_as_argument_type<int>::value ? -1 : 1];
+int is_unary_block6[is_unary_block_with_same_return_type_as_argument_type<int (^)()>::value ? -1 : 1];
+int is_unary_block7[is_unary_block_with_same_return_type_as_argument_type<int (^)(int, bool)>::value ? -1 : 1];
+int is_unary_block8[is_unary_block_with_same_return_type_as_argument_type<int (^)(bool)>::value ? -1 : 1];
+int is_unary_block9[is_unary_block_with_same_return_type_as_argument_type<int (^)(int)>::value ? 1 : -1];
+int is_unary_block10[is_unary_block_with_same_return_type_as_argument_type<int (^)(int, ...)>::value ? -1 : 1];
+int is_unary_block11[is_unary_block_with_same_return_type_as_argument_type<int (^ const)(int)>::value ? -1 : 1];
diff --git a/clang/test/SemaTemplate/temp_class_spec_neg.cpp b/clang/test/SemaTemplate/temp_class_spec_neg.cpp
new file mode 100644
index 0000000..be5fbb1
--- /dev/null
+++ b/clang/test/SemaTemplate/temp_class_spec_neg.cpp
@@ -0,0 +1,45 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T> struct vector;
+
+// C++ [temp.class.spec]p6:
+namespace N {
+  namespace M {
+    template<typename T> struct A; // expected-note{{here}}
+  }
+}
+
+template<typename T>
+struct N::M::A<T*> { }; // expected-warning{{C++11 extension}}
+
+// C++ [temp.class.spec]p9
+//   bullet 1
+template <int I, int J> struct A {}; 
+template <int I> struct A<I+5, I*2> {}; // expected-error{{depends on}} 
+template <int I, int J> struct B {}; 
+template <int I> struct B<I, I> {}; //OK 
+
+//   bullet 2
+template <class T, T t> struct C {};  // expected-note{{declared here}}
+template <class T> struct C<T, 1>; // expected-error{{specializes}}
+template <class T, T* t> struct C<T*, t>; // okay
+
+template< int X, int (*array_ptr)[X] > class A2 {}; // expected-note{{here}}
+int array[5]; 
+template< int X > class A2<X, &array> { }; // expected-error{{specializes}}
+
+template<typename T, int N, template<typename X> class TT>
+struct Test0;
+
+//   bullet 3
+template<typename T, int N, template<typename X> class TT>
+struct Test0<T, N, TT>; // expected-error{{does not specialize}}
+
+// C++ [temp.class.spec]p10
+template<typename T = int, // expected-error{{default template argument}}
+         int N = 17, // expected-error{{default template argument}}
+         template<typename X> class TT = ::vector> // expected-error{{default template argument}}
+  struct Test0<T*, N, TT> { };
+
+template<typename T> struct Test1;
+template<typename T, typename U>  // expected-note{{non-deducible}}
+  struct Test1<T*> { }; // expected-warning{{never be used}}
diff --git a/clang/test/SemaTemplate/temp_explicit.cpp b/clang/test/SemaTemplate/temp_explicit.cpp
new file mode 100644
index 0000000..80c90d0
--- /dev/null
+++ b/clang/test/SemaTemplate/temp_explicit.cpp
@@ -0,0 +1,151 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat %s
+//
+// Tests explicit instantiation of templates.
+template<typename T, typename U = T> class X0 { };
+
+namespace N {
+  template<typename T, typename U = T> class X1 { };
+}
+
+// Check the syntax of explicit instantiations.
+template class X0<int, float>;
+template class X0<int>; // expected-note{{previous}}
+
+template class N::X1<int>;
+template class ::N::X1<int, float>;
+
+using namespace N;
+
+// Check for some bogus syntax that probably means that the user
+// wanted to write an explicit specialization, but forgot the '<>'
+// after 'template'.
+template class X0<double> { }; // expected-error{{explicit specialization}}
+
+// Check for explicit instantiations that come after other kinds of
+// instantiations or declarations.
+template class X0<int, int>; // expected-error{{duplicate}}
+
+template<> class X0<char> { }; // expected-note{{previous}}
+template class X0<char>; // expected-warning{{ignored}}
+
+void foo(X0<short>) { }
+template class X0<short>;
+
+// Check that explicit instantiations actually produce definitions. We
+// determine whether this happens by placing semantic errors in the
+// definition of the template we're instantiating.
+template<typename T> struct X2; // expected-note{{declared here}}
+
+template struct X2<float>; // expected-error{{undefined template}}
+
+template<typename T>
+struct X2 {
+  void f0(T*); // expected-error{{pointer to a reference}}
+};
+
+template struct X2<int>; // okay
+template struct X2<int&>; // expected-note{{in instantiation of}}
+
+// Check that explicit instantiations instantiate member classes.
+template<typename T> struct X3 {
+  struct Inner {
+    void f(T*); // expected-error{{pointer to a reference}}
+  };
+};
+
+void f1(X3<int&>); // okay, Inner, not instantiated
+
+template struct X3<int&>; // expected-note{{instantiation}}
+
+template<typename T> struct X4 {
+  struct Inner {
+    struct VeryInner {
+      void f(T*); // expected-error 2{{pointer to a reference}}
+    };
+  };
+};
+
+void f2(X4<int&>); // okay, Inner, not instantiated
+void f3(X4<int&>::Inner); // okay, Inner::VeryInner, not instantiated
+
+template struct X4<int&>; // expected-note{{instantiation}}
+template struct X4<float&>; // expected-note{{instantiation}}
+
+// Check explicit instantiation of member classes
+namespace N2 {
+
+template<typename T>
+struct X5 {
+  struct Inner1 {
+    void f(T&);
+  };
+
+  struct Inner2 { // expected-note {{here}}
+    struct VeryInner {
+      void g(T*); // expected-error 2{{pointer to a reference}}
+    };
+  };
+};
+
+}
+
+template struct N2::X5<void>::Inner2;
+
+using namespace N2;
+template struct X5<int&>::Inner2; // expected-note{{instantiation}}
+
+void f4(X5<float&>::Inner2);
+template struct X5<float&>::Inner2; // expected-note{{instantiation}}
+
+namespace N3 {
+  template struct N2::X5<int>::Inner2; // expected-warning {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
+}
+
+struct X6 {
+  struct Inner { // expected-note{{here}}
+    void f();
+  };
+};
+
+template struct X6::Inner; // expected-error{{non-templated}}
+
+// PR5559
+template <typename T>
+struct Foo;
+
+template <>
+struct Foo<int> // expected-note{{header not required for explicitly-specialized}}
+{
+    template <typename U>
+    struct Bar
+    {};
+};
+
+template <> // expected-warning{{extraneous template parameter list}}
+template <>
+struct Foo<int>::Bar<void>
+{};
+
+namespace N1 {
+
+  template<typename T> struct X7 { }; // expected-note{{here}}
+
+  namespace Inner {
+    template<typename T> struct X8 { };
+  }
+
+  template struct X7<int>;
+  template struct Inner::X8<int>;
+}
+
+template<typename T> struct X9 { }; // expected-note{{here}}
+
+template struct ::N1::Inner::X8<float>;
+
+namespace N2 {
+  using namespace N1;
+
+  template struct X7<double>; // expected-warning{{must occur in namespace}}
+
+  template struct X9<float>; // expected-warning{{must occur at global scope}}
+}
diff --git a/clang/test/SemaTemplate/temp_explicit_cxx0x.cpp b/clang/test/SemaTemplate/temp_explicit_cxx0x.cpp
new file mode 100644
index 0000000..e37fcd7
--- /dev/null
+++ b/clang/test/SemaTemplate/temp_explicit_cxx0x.cpp
@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
+namespace N1 {
+
+  template<typename T> struct X0 { }; // expected-note{{here}}
+
+  namespace Inner {
+    template<typename T> struct X1 { };
+  }
+
+  template struct X0<int>;
+  template struct Inner::X1<int>;
+}
+
+template<typename T> struct X2 { }; // expected-note{{here}}
+
+template struct ::N1::Inner::X1<float>;
+
+namespace N2 {
+  using namespace N1;
+
+  template struct X0<double>; // expected-error{{must occur in namespace 'N1'}}
+
+  template struct X2<float>; // expected-error{{at global scope}}
+}
diff --git a/clang/test/SemaTemplate/temp_func_order.cpp b/clang/test/SemaTemplate/temp_func_order.cpp
new file mode 100644
index 0000000..908354b
--- /dev/null
+++ b/clang/test/SemaTemplate/temp_func_order.cpp
@@ -0,0 +1,95 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T>
+int &f0(T);
+
+template<typename T>
+float &f0(T*);
+
+void test_f0(int i, int *ip) {
+  int &ir = f0(i);
+  float &fr = f0(ip);
+}
+
+template<typename T, typename U>
+int &f1(T, U);
+
+template<typename T>
+float &f1(T, T);
+
+void test_f1(int i, float f) {
+  int &ir = f1(i, f);
+  float &fr1 = f1(i, i);
+  float &fr2 = f1(f, f);
+}
+
+template<typename T, typename U>
+struct A { };
+
+template<typename T>
+int &f2(T);
+
+template<typename T, typename U>
+float &f2(A<T, U>);
+
+template<typename T>
+double &f2(A<T, T>);
+
+void test_f2(int i, A<int, float> aif, A<int, int> aii) {
+  int &ir = f2(i);
+  float &fr = f2(aif);
+  double &dr = f2(aii);
+}
+
+template<typename T, typename U>
+int &f3(T*, U); // expected-note{{candidate}}
+
+template<typename T, typename U>
+float &f3(T, U*); // expected-note{{candidate}}
+
+void test_f3(int i, int *ip, float *fp) {
+  int &ir = f3(ip, i);
+  float &fr = f3(i, fp);
+  f3(ip, ip); // expected-error{{ambiguous}}
+}
+
+template<typename T>
+int &f4(T&);
+
+template<typename T>
+float &f4(const T&);
+
+void test_f4(int i, const int ic) {
+  int &ir1 = f4(i);
+  float &fr1 = f4(ic);
+}
+
+template<typename T, typename U>
+int &f5(T&, const U&); // expected-note{{candidate}}
+
+template<typename T, typename U>
+float &f5(const T&, U&); // expected-note{{candidate}}
+
+void test_f5(int i, const int ic) {
+  f5(i, i); // expected-error{{ambiguous}}
+}
+
+template<typename T, typename U>
+int &f6(T&, U&);
+
+template<typename T, typename U>
+float &f6(const T&, U&);
+
+void test_f6(int i, const int ic) {
+  int &ir = f6(i, i);
+  float &fr = f6(ic, ic);
+}
+
+struct CrazyFun {
+  template<typename T, typename U> operator A<T, U>();
+  template<typename T> operator A<T, T>();
+};
+
+void fun(CrazyFun cf) {
+  A<int, float> aif = cf;
+  A<int, int> aii = cf;  
+}
diff --git a/clang/test/SemaTemplate/template-class-traits.cpp b/clang/test/SemaTemplate/template-class-traits.cpp
new file mode 100644
index 0000000..4710294
--- /dev/null
+++ b/clang/test/SemaTemplate/template-class-traits.cpp
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s 
+#define T(b) (b) ? 1 : -1
+#define F(b) (b) ? -1 : 1
+
+struct HasVirt { virtual void a(); };
+template<class T> struct InheritPolymorph : HasVirt {};
+int t01[T(__is_polymorphic(InheritPolymorph<int>))];
+
diff --git a/clang/test/SemaTemplate/template-decl-fail.cpp b/clang/test/SemaTemplate/template-decl-fail.cpp
new file mode 100644
index 0000000..ad134cd
--- /dev/null
+++ b/clang/test/SemaTemplate/template-decl-fail.cpp
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T> typedef T X; // expected-error{{typedef cannot be a template}}
+
+template<typename T>
+enum t0 { A = T::x }; // expected-error{{enumeration cannot be a template}} \
+                      // expected-warning{{declaration does not declare anything}}
+
+enum e0 {};
+template<int x> enum e0 f0(int a=x) {}
diff --git a/clang/test/SemaTemplate/template-id-expr.cpp b/clang/test/SemaTemplate/template-id-expr.cpp
new file mode 100644
index 0000000..4416f92
--- /dev/null
+++ b/clang/test/SemaTemplate/template-id-expr.cpp
@@ -0,0 +1,98 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// PR5336
+template<typename FromCl>
+struct isa_impl_cl {
+ template<class ToCl>
+ static void isa(const FromCl &Val) { }
+};
+
+template<class X, class Y>
+void isa(const Y &Val) {   return isa_impl_cl<Y>::template isa<X>(Val); }
+
+class Value;
+void f0(const Value &Val) { isa<Value>(Val); }
+
+// Implicit template-ids.
+template<typename T>
+struct X0 {
+  template<typename U>
+  void f1();
+  
+  template<typename U>
+  void f2(U) {
+    f1<U>();
+  }
+};
+
+void test_X0_int(X0<int> xi, float f) {
+  xi.f2(f);
+}
+
+// Not template-id expressions, but they almost look like it.
+template<typename F>
+struct Y {
+  Y(const F&);
+};
+
+template<int I>
+struct X {
+  X(int, int);
+  void f() { 
+    Y<X<I> >(X<I>(0, 0)); 
+    Y<X<I> >(::X<I>(0, 0)); 
+  }
+};
+
+template struct X<3>;
+
+// 'template' as a disambiguator.
+// PR7030
+struct Y0 {
+  template<typename U>
+  void f1(U);
+
+  template<typename U>
+  static void f2(U);
+
+  void f3(int);
+
+  static int f4(int);
+  template<typename U>
+  static void f4(U);
+
+  template<typename U>
+  void f() {
+    Y0::template f1<U>(0);
+    Y0::template f1(0);
+    this->template f1(0);
+
+    Y0::template f2<U>(0);
+    Y0::template f2(0);
+
+    Y0::template f3(0); // expected-error {{'f3' following the 'template' keyword does not refer to a template}}
+    Y0::template f3(); // expected-error {{'f3' following the 'template' keyword does not refer to a template}}
+
+    int x;
+    x = Y0::f4(0);
+    x = Y0::f4<int>(0); // expected-error {{assigning to 'int' from incompatible type 'void'}}
+    x = Y0::template f4(0); // expected-error {{assigning to 'int' from incompatible type 'void'}}
+
+    x = this->f4(0);
+    x = this->f4<int>(0); // expected-error {{assigning to 'int' from incompatible type 'void'}}
+    x = this->template f4(0); // expected-error {{assigning to 'int' from incompatible type 'void'}}
+  }
+};
+
+struct A {
+  template<int I>
+  struct B {
+    static void b1();
+  };
+};
+
+template<int I>
+void f5() {
+  A::template B<I>::template b1(); // expected-error {{'b1' following the 'template' keyword does not refer to a template}}
+}
+
+template void f5<0>(); // expected-note {{in instantiation of function template specialization 'f5<0>' requested here}}
diff --git a/clang/test/SemaTemplate/template-id-printing.cpp b/clang/test/SemaTemplate/template-id-printing.cpp
new file mode 100644
index 0000000..047589b
--- /dev/null
+++ b/clang/test/SemaTemplate/template-id-printing.cpp
@@ -0,0 +1,141 @@
+// RUN: %clang_cc1 -fsyntax-only -ast-print %s | FileCheck %s
+namespace N {
+  template<typename T, typename U> void f(U);
+  template<int> void f();
+}
+
+void g() {
+  // CHECK: N::f<int>(3.14
+  N::f<int>(3.14);
+  
+  // CHECK: N::f<double>
+  void (*fp)(int) = N::f<double>;
+}
+
+
+// (NNS qualified) DeclRefExpr.
+namespace DRE {
+
+template <typename T>
+void foo();
+
+void test() {
+  // CHECK: DRE::foo<int>;
+  DRE::foo<int>;
+  // CHECK: DRE::template foo<int>;
+  DRE::template foo<int>;
+  // CHECK: DRE::foo<int>();
+  DRE::foo<int>();
+  // CHECK: DRE::template foo<int>();
+  DRE::template foo<int>();
+}
+
+} // namespace DRE
+
+
+// MemberExpr.
+namespace ME {
+
+struct S {
+  template <typename T>
+  void mem();
+};
+
+void test() {
+  S s;
+  // CHECK: s.mem<int>();
+  s.mem<int>();
+  // CHECK: s.template mem<int>();
+  s.template mem<int>();
+}
+
+} // namespace ME
+
+
+// UnresolvedLookupExpr.
+namespace ULE {
+
+template <typename T>
+int foo();
+
+template <typename T>
+void test() {
+  // CHECK: ULE::foo<T>;
+  ULE::foo<T>;
+  // CHECK: ULE::template foo<T>;
+  ULE::template foo<T>;
+}
+
+} // namespace ULE
+
+
+// UnresolvedMemberExpr.
+namespace UME {
+
+struct S {
+  template <typename T>
+  void mem();
+};
+
+template <typename U>
+void test() {
+  S s;
+  // CHECK: s.mem<U>();
+  s.mem<U>();
+  // CHECK: s.template mem<U>();
+  s.template mem<U>();
+}
+
+} // namespace UME
+
+
+// DependentScopeDeclRefExpr.
+namespace DSDRE {
+
+template <typename T>
+struct S;
+
+template <typename T>
+void test() {
+  // CHECK: S<T>::foo;
+  S<T>::foo;
+  // CHECK: S<T>::template foo;
+  S<T>::template foo;
+  // CHECK: S<T>::template foo<>;
+  S<T>::template foo<>;
+  // CHECK: S<T>::template foo<T>;
+  S<T>::template foo<T>;
+}
+
+} // namespace DSDRE
+
+
+// DependentScopeMemberExpr.
+namespace DSME {
+
+template <typename T>
+struct S;
+
+template <typename T>
+void test() {
+  S<T> s;
+  // CHECK: s.foo;
+  s.foo;
+  // CHECK: s.template foo;
+  s.template foo;
+  // CHECK: s.template foo<>;
+  s.template foo<>;
+  // CHECK: s.template foo<T>;
+  s.template foo<T>;
+}
+
+} // namespace DSME
+
+namespace DSDRE_withImplicitTemplateArgs {
+
+template <typename T> void foo() {
+  // CHECK: T::template bar();
+  T::template bar();
+}
+
+} // namespace DSDRE_withImplicitTemplateArgs
diff --git a/clang/test/SemaTemplate/typename-specifier-2.cpp b/clang/test/SemaTemplate/typename-specifier-2.cpp
new file mode 100644
index 0000000..551cac3
--- /dev/null
+++ b/clang/test/SemaTemplate/typename-specifier-2.cpp
@@ -0,0 +1,30 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename MetaFun, typename T>
+struct bind_metafun {
+  typedef typename MetaFun::template apply<T> type;
+};
+
+struct add_pointer {
+  template<typename T>
+  struct apply {
+    typedef T* type;
+  };
+};
+
+int i;
+// FIXME: if we make the declarator below a pointer (e.g., with *ip),
+// the error message isn't so good because we don't get the handy
+// 'aka' telling us that we're dealing with an int**. Should we fix
+// getDesugaredType to dig through pointers and such?
+bind_metafun<add_pointer, int>::type::type ip = &i;
+bind_metafun<add_pointer, float>::type::type fp = &i; // expected-error{{cannot initialize a variable of type 'bind_metafun<add_pointer, float>::type::type' (aka 'float *') with an rvalue of type 'int *'}}
+
+
+template<typename T>
+struct extract_type_type {
+  typedef typename T::type::type t;
+};
+
+double d;
+extract_type_type<bind_metafun<add_pointer, double> >::t dp = &d;
diff --git a/clang/test/SemaTemplate/typename-specifier-3.cpp b/clang/test/SemaTemplate/typename-specifier-3.cpp
new file mode 100644
index 0000000..a463d88
--- /dev/null
+++ b/clang/test/SemaTemplate/typename-specifier-3.cpp
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// PR4364
+template<class T> struct a {
+  T b() {
+    return typename T::x();
+  }
+};
+struct B {
+  typedef B x;
+};
+B c() {
+  a<B> x;
+  return x.b();
+}
+
+// Some extra tests for invalid cases
+template<class T> struct test2 { T b() { return typename T::a; } }; // expected-error{{expected '(' for function-style cast or type construction}}
+template<class T> struct test3 { T b() { return typename a; } }; // expected-error{{expected a qualified name after 'typename'}}
diff --git a/clang/test/SemaTemplate/typename-specifier-4.cpp b/clang/test/SemaTemplate/typename-specifier-4.cpp
new file mode 100644
index 0000000..44cf966
--- /dev/null
+++ b/clang/test/SemaTemplate/typename-specifier-4.cpp
@@ -0,0 +1,164 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+template<typename T, typename U> 
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+template<typename MetaFun, typename T1, typename T2>
+struct metafun_apply2 {
+  typedef typename MetaFun::template apply<T1, T2> inner;
+  typedef typename inner::type type;
+};
+
+template<typename T, typename U> struct pair;
+
+struct make_pair {
+  template<typename T1, typename T2>
+  struct apply {
+    typedef pair<T1, T2> type;
+  };
+};
+
+int a0[is_same<metafun_apply2<make_pair, int, float>::type, 
+               pair<int, float> >::value? 1 : -1];
+int a1[is_same<
+         typename make_pair::template apply<int, float>, // expected-warning{{'template' keyword outside of a template}} \
+       // expected-warning{{'typename' occurs outside of a template}}
+         make_pair::apply<int, float>
+       >::value? 1 : -1];
+
+template<typename MetaFun>
+struct swap_and_apply2 {
+  template<typename T1, typename T2>
+  struct apply {
+    typedef typename MetaFun::template apply<T2, T1> new_metafun;
+    typedef typename new_metafun::type type;
+  };
+};
+
+int a2[is_same<swap_and_apply2<make_pair>::apply<int, float>::type, 
+               pair<float, int> >::value? 1 : -1];
+
+template<typename MetaFun>
+struct swap_and_apply2b {
+  template<typename T1, typename T2>
+  struct apply {
+    typedef typename MetaFun::template apply<T2, T1>::type type;
+  };
+};
+
+int a3[is_same<swap_and_apply2b<make_pair>::apply<int, float>::type, 
+               pair<float, int> >::value? 1 : -1];
+
+template<typename T>
+struct X0 {
+  template<typename U, typename V>
+  struct Inner;
+  
+  void f0(X0<T>::Inner<T*, T&>); // expected-note{{here}}
+  void f0(typename X0<T>::Inner<T*, T&>); // expected-error{{redecl}}
+
+  void f1(X0<T>::Inner<T*, T&>); // expected-note{{here}}
+  void f1(typename X0<T>::template Inner<T*, T&>); // expected-error{{redecl}}
+
+  void f2(typename X0<T>::Inner<T*, T&>::type); // expected-note{{here}}
+  void f2(typename X0<T>::template Inner<T*, T&>::type); // expected-error{{redecl}}
+};
+
+namespace PR6236 {
+  template<typename T, typename U> struct S { };
+  
+  template<typename T> struct S<T, T> {
+    template<typename U> struct K { };
+    
+    void f() {
+      typedef typename S<T, T>::template K<T> Foo;
+    }
+  };
+}
+
+namespace PR6268 {
+  template <typename T>
+  struct Outer {
+    template <typename U>
+    struct Inner {};
+
+    template <typename U>
+    typename Outer<T>::template Inner<U>
+    foo(typename Outer<T>::template Inner<U>);
+  };
+
+  template <typename T>
+  template <typename U>
+  typename Outer<T>::template Inner<U>
+  Outer<T>::foo(typename Outer<T>::template Inner<U>) {
+    return Inner<U>();
+  }
+}
+
+namespace PR6463 {
+  struct B { typedef int type; }; // expected-note 2{{member found by ambiguous name lookup}}
+  struct C { typedef int type; }; // expected-note 2{{member found by ambiguous name lookup}}
+
+  template<typename T>
+  struct A : B, C { 
+    type& a(); // expected-error{{found in multiple base classes}}
+    int x; 
+  };
+
+  // FIXME: Improve source location info here.
+  template<typename T>
+  typename A<T>::type& A<T>::a() { // expected-error{{found in multiple base classes}}
+    return x;
+  }
+}
+
+namespace PR7419 {
+  template <typename T> struct S {
+    typedef typename T::Y T2;
+    typedef typename T2::Z T3;
+    typedef typename T3::W T4;
+    T4 *f();
+
+    typedef typename T::template Y<int> TT2;
+    typedef typename TT2::template Z<float> TT3;
+    typedef typename TT3::template W<double> TT4;
+    TT4 g();
+  };
+
+  template <typename T> typename T::Y::Z::W *S<T>::f() { }
+  template <typename T> typename T::template Y<int>::template Z<float>::template W<double> S<T>::g() { }
+}
+
+namespace rdar8740998 {
+  template<typename T>
+  struct X : public T {
+    using T::iterator; // expected-note{{add 'typename' to treat this using declaration as a type}} \
+    // expected-error{{dependent using declaration resolved to type without 'typename'}}
+
+    void f() {
+      typename X<T>::iterator i; // expected-error{{typename specifier refers to a dependent using declaration for a value 'iterator' in 'X<T>'}}
+    }
+  };
+
+  struct HasIterator {
+    typedef int *iterator; // expected-note{{target of using declaration}}
+  };
+
+  void test_X(X<HasIterator> xi) { // expected-note{{in instantiation of template class}}
+    xi.f();
+  }
+}
+
+namespace rdar9068589 {
+  // From GCC PR c++/13950
+  template <class T> struct Base {};
+  template <class T> struct Derived: public Base<T> {
+    typename Derived::template Base<double>* p1;
+  };
+}
diff --git a/clang/test/SemaTemplate/typename-specifier.cpp b/clang/test/SemaTemplate/typename-specifier.cpp
new file mode 100644
index 0000000..9eb4f33
--- /dev/null
+++ b/clang/test/SemaTemplate/typename-specifier.cpp
@@ -0,0 +1,117 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+namespace N {
+  struct A {
+    typedef int type;
+  };
+
+  struct B {
+  };
+
+  struct C {
+    struct type { };
+    int type; // expected-note 2{{referenced member 'type' is declared here}}
+  };
+}
+
+int i;
+
+typename N::A::type *ip1 = &i; // expected-warning{{'typename' occurs outside of a template}}
+typename N::B::type *ip2 = &i; // expected-error{{no type named 'type' in 'N::B'}} \
+// expected-warning{{'typename' occurs outside of a template}}
+typename N::C::type *ip3 = &i; // expected-error{{typename specifier refers to non-type member 'type'}} \
+// expected-warning{{'typename' occurs outside of a template}}
+
+void test(double d) {
+  typename N::A::type f(typename N::A::type(a)); // expected-warning{{parentheses were disambiguated as a function declarator}} \
+  // expected-warning 2{{'typename' occurs outside of a template}}
+  int five = f(5);
+  
+  using namespace N;
+  for (typename A::type i = 0; i < 10; ++i) // expected-warning{{'typename' occurs outside of a template}}
+    five += 1;
+
+  const typename N::A::type f2(d); // expected-warning{{'typename' occurs outside of a template}}
+}
+
+namespace N {
+  template<typename T>
+  struct X {
+    typedef typename T::type type; // expected-error {{no type named 'type' in 'N::B'}} \
+    // expected-error {{no type named 'type' in 'B'}} \
+    // FIXME: location info for error above isn't very good \
+    // expected-error 2{{typename specifier refers to non-type member 'type'}} \
+    // expected-error{{type 'int' cannot be used prior to '::' because it has no members}}
+  };
+}
+
+N::X<N::A>::type *ip4 = &i;
+N::X<N::B>::type *ip5 = &i; // expected-note{{in instantiation of template class 'N::X<N::B>' requested here}}
+N::X<N::C>::type *ip6 = &i; // expected-note{{in instantiation of template class 'N::X<N::C>' requested here}}
+
+N::X<int>::type fail1; // expected-note{{in instantiation of template class 'N::X<int>' requested here}}
+
+template<typename T>
+struct Y {
+  typedef typename N::X<T>::type *type; // expected-note{{in instantiation of template class 'N::X<B>' requested here}} \
+  // expected-note{{in instantiation of template class 'N::X<C>' requested here}}
+};
+
+struct A {
+  typedef int type;
+};
+
+struct B {
+};
+
+struct C {
+  struct type { };
+  int type; // expected-note{{referenced member 'type' is declared here}}
+};
+
+::Y<A>::type ip7 = &i;
+::Y<B>::type ip8 = &i; // expected-note{{in instantiation of template class 'Y<B>' requested here}}
+::Y<C>::type ip9 = &i; // expected-note{{in instantiation of template class 'Y<C>' requested here}}
+
+template<typename T> struct D {
+  typedef typename T::foo foo;  // expected-error {{type 'long' cannot be used prior to '::' because it has no members}}
+  typedef typename foo::bar bar;
+};
+
+D<long> struct_D;  // expected-note {{in instantiation of template class 'D<long>' requested here}}
+
+template<typename T> struct E {
+  typedef typename T::foo foo;
+  typedef typename foo::bar bar;  // expected-error {{type 'foo' (aka 'double') cannot be used prior to '::' because it has no members}}
+};
+
+struct F {
+  typedef double foo;
+};
+
+E<F> struct_E; // expected-note {{in instantiation of template class 'E<F>' requested here}}
+
+template<typename T> struct G {
+  typedef typename T::foo foo;
+  typedef typename foo::bar bar;
+};
+
+struct H {
+  struct foo {
+    typedef double bar;
+  };
+};
+
+G<H> struct_G;
+
+namespace PR10925 {
+  template< int mydim, typename Traits >
+  class BasicGeometry
+  {
+    typedef int some_type_t;
+  };
+
+  template<class ctype, int mydim, int coorddim>
+  class MockGeometry : BasicGeometry<mydim, int>{
+    using typename BasicGeometry<mydim, int>::operator[]; // expected-error {{typename is allowed for identifiers only}}
+  };
+}
diff --git a/clang/test/SemaTemplate/typo-dependent-name.cpp b/clang/test/SemaTemplate/typo-dependent-name.cpp
new file mode 100644
index 0000000..96554e9
--- /dev/null
+++ b/clang/test/SemaTemplate/typo-dependent-name.cpp
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T>
+struct Base {
+  T inner;
+};
+
+template<typename T>
+struct X {
+  template<typename U>
+  struct Inner {
+  };
+
+  bool f(T other) {
+    return this->inner < other;
+  }
+};
diff --git a/clang/test/SemaTemplate/unresolved-construct.cpp b/clang/test/SemaTemplate/unresolved-construct.cpp
new file mode 100644
index 0000000..bb9ed8e
--- /dev/null
+++ b/clang/test/SemaTemplate/unresolved-construct.cpp
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+class A
+{
+public:
+    A() {}
+
+    template <class _F>
+        explicit A(_F&& __f);
+
+    A(A&&) {}
+    A& operator=(A&&) {return *this;}
+};
+
+template <class T>
+void f(T t)
+{
+  A a;
+  a = f(t);
+}
diff --git a/clang/test/SemaTemplate/unused-variables.cpp b/clang/test/SemaTemplate/unused-variables.cpp
new file mode 100644
index 0000000..1b9350b
--- /dev/null
+++ b/clang/test/SemaTemplate/unused-variables.cpp
@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -fsyntax-only -Wunused -verify %s
+
+struct X0 {
+  ~X0();
+};
+
+struct X1 { };
+
+template<typename T>
+void f() {
+  X0 x0;
+  X1 x1; // expected-warning{{unused variable 'x1'}}
+}
+
+template<typename T, typename U>
+void g() {
+  T t;
+  U u; // expected-warning{{unused variable 'u'}}
+}
+
+template void g<X0, X1>(); // expected-note{{in instantiation of}}
diff --git a/clang/test/SemaTemplate/value-dependent-null-pointer-constant.cpp b/clang/test/SemaTemplate/value-dependent-null-pointer-constant.cpp
new file mode 100644
index 0000000..223500e
--- /dev/null
+++ b/clang/test/SemaTemplate/value-dependent-null-pointer-constant.cpp
@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 -fsyntax-only %s
+
+template<typename T, int N>
+struct X0 {
+  const char *f0(bool Cond) {
+    return Cond? "honk" : N;
+  }
+
+  const char *f1(bool Cond) {
+    return Cond? N : "honk";
+  }
+  
+  bool f2(const char *str) {
+    return str == N;
+  }
+};
+
+// PR4996
+template<unsigned I> int f0() { 
+  return __builtin_choose_expr(I, 0, 1); 
+}
+
+// PR5041
+struct A { };
+
+template <typename T> void f(T *t)
+{
+  (void)static_cast<void*>(static_cast<A*>(t));
+}
diff --git a/clang/test/SemaTemplate/virtual-member-functions.cpp b/clang/test/SemaTemplate/virtual-member-functions.cpp
new file mode 100644
index 0000000..974f664
--- /dev/null
+++ b/clang/test/SemaTemplate/virtual-member-functions.cpp
@@ -0,0 +1,86 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+namespace PR5557 {
+template <class T> struct A {
+  A();
+  virtual void anchor();
+  virtual int a(T x);
+};
+template<class T> A<T>::A() {}
+template<class T> void A<T>::anchor() { }
+
+template<class T> int A<T>::a(T x) { 
+  return *x; // expected-error{{requires pointer operand}}
+}
+
+void f(A<int> x) {
+  x.anchor(); // expected-note{{instantiation}}
+}
+
+template<typename T>
+struct X {
+  virtual void f();
+};
+
+template<>
+void X<int>::f() { }
+}
+
+template<typename T>
+struct Base {
+  virtual ~Base() { 
+    int *ptr = 0;
+    T t = ptr; // expected-error{{cannot initialize}}
+  }
+};
+
+template<typename T>
+struct Derived : Base<T> {
+  virtual void foo() { }
+};
+
+template struct Derived<int>; // expected-note {{in instantiation of member function 'Base<int>::~Base' requested here}}
+
+template<typename T>
+struct HasOutOfLineKey {
+  HasOutOfLineKey() { } 
+  virtual T *f(float *fp);
+};
+
+template<typename T>
+T *HasOutOfLineKey<T>::f(float *fp) {
+  return fp; // expected-error{{cannot initialize return object of type 'int *' with an lvalue of type 'float *'}}
+}
+
+HasOutOfLineKey<int> out_of_line; // expected-note{{in instantiation of member function 'HasOutOfLineKey<int>::f' requested here}}
+
+namespace std {
+  class type_info;
+}
+
+namespace PR7114 {
+  class A { virtual ~A(); }; // expected-note{{declared private here}}
+
+  template<typename T>
+  class B {
+  public:
+    class Inner : public A { }; // expected-error{{base class 'PR7114::A' has private destructor}}
+    static Inner i;
+    static const unsigned value = sizeof(i) == 4;
+  };
+
+  int f() { return B<int>::value; }
+
+  void test_typeid(B<float>::Inner bfi) {
+    (void)typeid(bfi); // expected-note{{implicit default destructor}}
+  }
+
+  template<typename T>
+  struct X : A {
+    void f() { }
+  };
+
+  void test_X(X<int> xi, X<float> xf) {
+    xi.f();
+  }
+}
-- 
cgit v1.2.3