Variable templates w/ partial support for static data members

[lvoufo]

Summary

This patch should cover all aspects of top-level variable template declarations, including explicit instantiations and (partial) specializations.
I have also incorporated comments from the first patch.
I am still completing test cases, but thought I'd send this out for the time being, to catch earlier misses or get a better sense of what other test cases to cover.

[rsmith]

include/clang/AST/Decl.h

1150

Indentation.

include/clang/AST/DeclTemplate.h

2285

Missing period.

2310

Missing period.

2318–2326

Indentation.

2443

"members of the variable template"? Maybe "the initializer of the variable template"?

2484

Last sentence here seems incorrect; drop it?

2545

"*" on the right, please.

2552–2555

Is this necessary, given that we store specializations in a FoldingSetVector (which maintains order itself)?

2565–2578

Indentation.

2596

Indentation.

2660–2661

Extra "template" at the start of the second line.

2691

Isn't this handled by the Profile support in the base class?

2712–2713

... for this *variable* template

2716–2717

... for this *variable* template

2742

Indentation.

2756

... underlying variable declaration

2762

... primary variable template pattern.

2769–2773

Indentation.

2836–2844

This doesn't make sense for a variable template; just remove it.

include/clang/AST/RecursiveASTVisitor.h

1484–1532

Once this patch lands, it'd be good to go back over this and clean up this duplication: traversal for variable templates, class templates, and function templates all use exactly the same code (other than some trivial differences in class names).

1886

Grammar.

include/clang/Basic/DiagnosticSemaKinds.td

2843

We usually word this as "variable templates are a C++1y extension". Please also add a CXXPre1yCompat warning, "variable templates are incompatible with C++ standards before C++1y". (The idea is to allow people to compile with -std=c++1y, and get warned if their code would not be portable to earlier standard versions.)

3113

Indentation.

3114–3115

Should this say "... cannot be redefined" ? The corresponding rule for class template partial specializations in 14.5.5/5 allows redeclarations.

3119

Indentation.

3274–3276

Where's %1?

include/clang/Sema/Sema.h

1386

"||" on previous line, please.

1391–1399

Remove this assert; it's covered by your default case below.

5033

Capital I.

6373–6374

"*" on the right, please

include/clang/Sema/Template.h

385

Indentation

451

Indentation (and probably unnecessary line wrapping)

499–501

Reformat this, please

lib/AST/ASTContext.cpp

1062

Accidental change?

lib/AST/ASTImporter.cpp

106

Updates to ASTImporter.cpp aren't generally necessary: it's already *very* incomplete (it doesn't support function templates, for instance) and would require substantial work to make it complete.

2038

I think this FIXME fits better in the caller.

4175

We don't support variable templates declared at function scope, right?

4236–4237

Did you intend to reuse ImportDefinition here?

4318

class?

4327

function?

lib/AST/Decl.cpp

1563

You're not using PrevDecl here; remove it?

2000–2002

Indentation

2009–2011

Indentation.

lib/AST/DeclTemplate.cpp

971–976

Indentation.

983

Indentation (and likewise later functions in this file).

1208–1209

Maybe adopt them into DC (though they should presumably be there already).

lib/Parse/Parser.cpp

1431

Update this comment.

1646–1649

No linebreak here.

lib/Sema/SemaDecl.cpp

4833–4839

"Is", not "is", please.

4836

It seems error-prone to have this in scope for the entire function but only use it when declaring a variable template.

4914–4918

Don't bail out here, just accept the variable template as if we were in C++1y mode.

4931

Indentation.

4939

What happens in the "else" case of this? (template<> int n;)

4980

Extra space after paren.

4987–4990

Extra spaces after ( here.

5017–5018

No linebreak here.

5033–5041

Doesn't look like it; it looks incorrect for variable templates and redundant otherwise.

5231–5232

Should do this regardless of language mode.

5249

It might be clearer to set this on NewTemplate (even though they share a CommonPtr).

lib/Sema/SemaExpr.cpp

1541–1542

Remove this.

1553–1559

Reindent. Also, assert(!TemplateArgs) here?

2036

No C++1y check here; we're supporting variable templates in earlier languages as an extension.

2045–2046

Nope.

11184–11185

Remove comment: no need for a special case here; variable template specializations never have automatic storage duration so aren't candidates to be captured anyway.

11571

Did you mean to leave this in the patch?

11603–11604

Remove this.

11622–11623

Should this check be outside the usable-in-constant-expressions check?

11641–11648

Revert these (non-)changes.

lib/Sema/SemaTemplate.cpp

2281–2283

Indentation.

2293

Drop this comment, it's not really useful to future readers of the code.

2300

"Is", not "is"

2303

"D must be a template-id" ?

2354

Space after "if".

2388–2395

Indentation.

2407

No parens here.

2440

...of a member variable

2443

As before, this might be clearer if you call setMemberSpecialization on Partial.

2445

...of the variable template

2447

...this variable template...

2524

Missing space after 'if'.

2552–2553

Remove.

2559

"*" on the right.

2567

Indentation.

2591

What happens when the type of the variable depends on the initializer:

template<typename T> auto var1 = T();
template<int...N> int var2[] = { N... };

2591–2594

Indentation.

2617–2660

Please factor the common code out of TemplateDeclInstantiator::VisitVarDecl and here.

2668

Please do. It looks like it should be straightforward to extract this as a template parameterized on the relevant type of partial specialization decl.

2781

"// Build"

2807–2808

Remove.

7260–7261

Remove.

7277

Is this const_cast necessary?

7278

Space after 'if'.

7289

Space after 'if'

7297–7308

No linebreak here.

7330

Why check the scope specifier here? It looks like this won't reject:

template<typename T> T var = T();
template int var;

Do we handle that elsewhere?

Please also update the preceding quotation based on N3690 (the new wording includes some relevant text about variable templates.)

7341

This assert is dead. Maybe change the "else if (PrevTemplate) {" below to "else { assert(PrevTemplate && ...)" ?

7347

Space after 'if'

lib/Sema/SemaTemplateDeduction.cpp

2412

...given variable template

4477–4488

s/class/variable/g

4497–4498

Remove?

[rsmith]

lib/Sema/SemaTemplateDeduction.cpp

4489–4550

Instead of duplicating it, can you template the existing getMoreSpecializedPartialSpecialization on the type of PartialSpecializationDecl?

lib/Sema/SemaTemplateInstantiateDecl.cpp

324–325

"In C++11"?

330–331

Remove.

336

Indentation / join with previous line.

389

No test for C++1y here.

490–491

No linebreak here.

1090–1092

Remove.

1114–1115

Add a FIXME here to revisit this.

1219

Can this happen? Should we assert here?

1223–1224

Likewise.

2789

Remove?

3427

Can this happen?

3429–3431

Should we call ActOnInitializerError here?

3439–3445

Why commented out?

3494

"*" on the right. Also, maybe inline the call into the 'if', since you're not otherwise using the variable.

3514

Indentation.

3540

Capital P.

3546

Space after 'if'

3885–3898

Remove?

4155

Space after 'if'.

4155–4157

Use

if (VarTemplateSpecializationDecl *VarSpec = dyn_cast<VarTemplateSpecializationDecl>(D)) {

Rather than isa + cast.

4161–4163

No braces.

4348–4349

Remove.

lib/Sema/TreeTransform.h

6205

Nothing changed in this file but whitespace; revert?

lib/Serialization/ASTWriterDecl.cpp

1195–1207

s/CT/VT/g

1211–1212

Remove

1217–1271

It looks like the corresponding code in ASTDeclReader is missing?

[lvoufo]

include/clang/AST/Decl.h

1205

Right. I've removed PrevDecl from VarDecl.

include/clang/AST/RecursiveASTVisitor.h

1484–1532

Right. I've added a FIXME to this effect.

lib/AST/ASTImporter.cpp

106

So... Is this an invitation to drop these changes, or to keep them around at least for future-proofness reasons?

lib/AST/Decl.cpp

1563

Ow. Good catch.

lib/AST/DeclTemplate.cpp

1208–1209

I think they should be in DC by now. I leave this commented out for now, and remove it once I'm sure that there are no unforeseen corner case.

lib/Sema/SemaExpr.cpp

11571

Yes. But I don't find it necessary anymore.

lib/Sema/SemaTemplate.cpp

2591

Added a FIXME for now.

7330

It parses "template int var" as an explicit instantiation and complains about "too few arguments".

lib/Sema/SemaTemplateDeduction.cpp

4489–4550

Marked as TODO.

lib/Sema/SemaTemplateInstantiateDecl.cpp

1114–1115

Removed.

3439–3445

I had meant to remove it. This block of code is only used in TemplateDeclInstantiator::VisitVarDecl()

lib/Serialization/ASTWriterDecl.cpp

1217–1271

Right. I had missed that. Thanks.

[lvoufo]

This is an update from the previous patch with some-but-not-all support for static data member templates.

Comments from previous reviews have also been incorporated here.
Missing features are documented as FIXMEs and TODOs.

More test cases, including as requested in the reviews, are under development.

[lvoufo]

auto variable templates should now behave according to the standard.

Next up:

• proper diagnosis for redefinitions (see notes in test file)
• complete static data member templates coverage
• more elaborate test cases

[lvoufo]

Cleaned up the tests cases a little bit, reviewing diagnosis for redefinitions of variable templates and variable template specializations.

Some issues with static data members seem to have resolved themselves as well. However, there are still two important issues, identified in the test files, that need be addressed before working on further test cases:

1. const pointer-typed static data member templates seem mis-diagnosed.
2. The explicit specialization and instantiation of static data member templates of class templates leads to runtime exceptions.

I will be inserting more test cases as indicated in the previous reviews, while treating the above issues as more of a priority. Please let me know if you disagree...

[lvoufo]

The runtime exceptions generated by static data member templates of class templates have been resolved via a somewhat ugly hack.
Related type substitution is still not working properly. Need to revise TemplateDeclInstantiator's VisitVarTemplateDEcl() and VisitVarTemplatePartialSpecializationDecl() to this effect...

[lvoufo]

Updated test cases, showing variable templates working even when C++1y is not enabled. appropriate warnings are generated, also indicating feature compatibility.

Of all the test cases requested in previous review, the following constitute the main remaining ones:

• Tests for PCH (serialization/deserialization)
• Tests for name mangling of variable templates, and IR generation generally (for instance, implicit internal linkage of variable template that instantiates to a const-qualified type).

All other tests cases will be updated as the feature is completed.

[rsmith]

include/clang/AST/ASTContext.h

275

Typo "synonym"

include/clang/AST/Decl.h

954

No parens around these.

include/clang/AST/DeclTemplate.h

2402–2403

Extra newline in this comment.

2436–2443

Likewise.

2620–2621

And here.

include/clang/AST/RecursiveASTVisitor.h

1535–1537

Join these lines.

1902–1903

Join these lines.

include/clang/Basic/DiagnosticSemaKinds.td

3066–3068

It looks like you don't use this diagnostic; remove.

3110

This has two spaces in a row if %0 is 0.

include/clang/Sema/Template.h

381–386

You don't appear to use these for anything yet; I assume support for class-scope partial specialization of variable templates will follow in a separate patch?

lib/AST/ASTContext.cpp

1044–1049

It looks like this has no callers; remove it.

7995–7996

Why is this commented out?

lib/AST/Decl.cpp

1987

Remove commented out code.

lib/Parse/ParseCXXInlineMethods.cpp

59–62 ↗

(On Diff #3182)

This can't happen: FnD is always a function declaration here. (We only handle initializers here in order to deal with a "= 0" pure-specifier.)

lib/Parse/ParseDecl.cpp

1805–1816

This check seems like it belongs in Sema.

lib/Parse/ParseExprCXX.cpp

564–569 ↗

(On Diff #3182)

This should be handled elsewhere: perhaps in ParseOptionalCXXScopeSpecifier's handling of annot_template_id.

lib/Sema/SemaDecl.cpp

4945

if (TemplateParams->empty() &&

4962

... partial or explicit specialization.

5018–5019

Redundant newline.

lib/Sema/SemaTemplate.cpp

216

Remove.

2583

*do not

lib/Sema/SemaTemplateDeduction.cpp

2404

... given variable template

lib/Sema/SemaTemplateInstantiateDecl.cpp

2313–2315

Is it really valid for a type to be defined in a variable template declaration? That seems like a big can of worms.

[rsmith]

test/SemaCXX/cxx1y-variable-templates_in_class.cpp

161–169 ↗

(On Diff #3188)

This is going to be a maintenance nightmare if we ever change these tests. Please instead turn the relevant warnings off for this test, and add a test for this warning to test/SemaCXX/cxx98-compat.cpp

test/SemaCXX/cxx1y-variable-templates_top_level.cpp

403–413 ↗

(On Diff #3188)

Put these next to the corresponding parts of the test, and use relative line numbers not absolute, to make the test less fragile.

416–419 ↗

(On Diff #3188)

Likewise please turn this warning off.

[lvoufo]

test/SemaCXX/cxx1y-variable-templates_in_class.cpp

161–169 ↗

(On Diff #3188)

Yes. I was a little bit worried about this too. But I wasn't sure how to balance out thoroughness against maintenance...

I will change this in the next update.

test/SemaCXX/cxx1y-variable-templates_top_level.cpp

403–413 ↗

(On Diff #3188)

Ok.

416–419 ↗

(On Diff #3188)

Ok.

[lvoufo]

include/clang/AST/RecursiveASTVisitor.h

1902–1903

Yeah. I need to be a bit more attentive with clang-format.

include/clang/Basic/DiagnosticSemaKinds.td

3066–3068

Right. This must have been lost with previous revisions.

3110

Fixed in one of the lasts patches after this...

include/clang/Sema/Template.h

381–386

Probably. We have some class-scope partial specialization right now. However, it looks like I have not well mapped the behavior from nested templates. So, I guess I'll know for sure after that is done.

lib/AST/ASTContext.cpp

1044–1049

I have replaced it with getTemplateOrSpecializationInfo(). However, I'd like to make sure that static data member templates are working well before I remove it completely...

7995–7996

I was in the process of replacing it with TemplateOrInstantiation. Removed.

lib/AST/Decl.cpp

1987

Same logic as earlier. I am not 100% confident that it is not needed yet. I will eventually removed it when/if I get static data member templates to work properly. I added a FIXME for now.

lib/Parse/ParseCXXInlineMethods.cpp

59–62 ↗

(On Diff #3182)

Ok.

lib/Parse/ParseDecl.cpp

1805–1816

Ok.

lib/Parse/ParseExprCXX.cpp

564–569 ↗

(On Diff #3182)

Ok. Noted.

lib/Sema/SemaTemplateInstantiateDecl.cpp

2313–2315

I'm not sure. But perhaps this is another question to add onto my "notes".

I interpret this as allowing things like

template<typename T> class { } var = ...;

since "class { }" is anonymous and this is okay:

class {} var;

But that can lead to things like

template<typename T> class {T foo;} var = ...;

Which can be "tricky" to manage...

Should we just reject all such cases, or at least just allow the first one, where the anonymous type is non-dependent?

[lvoufo]

lib/Sema/SemaDecl.cpp

4945

Small note. There is no "empty()" in TemplateParameterList.

[lvoufo]

Reviews incorporated. Ready to push?

[rsmith]

OK, please go ahead and commit this, all the FIXMEs look fine to handle in subsequent commits. Many thanks!

test/SemaCXX/cxx1y-variable-templates_in_class.cpp

1–2 ↗

(On Diff #3204)

Please use -Wno-c++11-extensions -Wno-c++1y-extensions here, rather than -w.

test/SemaCXX/cxx1y-variable-templates_top_level.cpp

1–2 ↗

(On Diff #3204)

Likewise.

[Eugene.Zelenko]

Committed in rL187762.

include/clang/AST/ASTContext.h

   llvm::DenseMap<const VarDecl *, MemberSpecializationInfo *> 
     InstantiatedFromStaticDataMember;
 
+  /// \brief A mapping to contain the template or declaration that
+  /// that a variable declaration describes or was instantiated from,
+  /// respectively.
+  ///
+  /// For non-templates, this value will be NULL. For variable
+  /// declarations that describe a variable template, this will be a
+  /// pointer to a VarTemplateDecl. For static data members
+  /// of class template specializations, this will be the
+  /// MemberSpecializationInfo referring to the member class that was
+  /// instantiated or specialized.
+  ///
+  /// FIXME: With support for static data member templates, unify with
+  ///        InstantiatedFRomStaticDataMember?
+public: 
+  typedef llvm::PointerUnion<VarTemplateDecl*, MemberSpecializationInfo*>
+    TemplateOrSpecializationInfo;
+private:
+  llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>
+    TemplateOrInstantiation;
+
   /// \brief Keeps track of the declaration from which a UsingDecl was
   /// created during instantiation.
   ///

   MemberSpecializationInfo *getInstantiatedFromStaticDataMember(
                                                            const VarDecl *Var);
 
+  TemplateOrSpecializationInfo getTemplateOrSpecializationInfo( 
+                                                           const VarDecl* Var);
+
   FunctionDecl *getClassScopeSpecializationPattern(const FunctionDecl *FD);
 
   void setClassScopeSpecializationPattern(FunctionDecl *FD,

                                            TemplateSpecializationKind TSK,
                         SourceLocation PointOfInstantiation = SourceLocation());
 
+  void setTemplateOrSpecializationInfo(VarDecl *Inst,
+               TemplateOrSpecializationInfo TSI);
+
   /// \brief If the given using decl \p Inst is an instantiation of a
   /// (possibly unresolved) using decl from a template instantiation,
   /// return it.

include/clang/AST/ASTMutationListener.h

   class QualType;
   class TagDecl;
   class VarDecl;
+  class VarTemplateDecl;
+  class VarTemplateSpecializationDecl;
 
 /// \brief An abstract interface that should be implemented by listeners
 /// that want to be notified when an AST entity gets modified after its

 
   /// \brief A template specialization (or partial one) was added to the
   /// template declaration.
+  virtual void AddedCXXTemplateSpecialization(const VarTemplateDecl *TD,
+                                    const VarTemplateSpecializationDecl *D) {}
+
+  /// \brief A template specialization (or partial one) was added to the
+  /// template declaration.
   virtual void AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
                                               const FunctionDecl *D) {}
 

include/clang/AST/Decl.h

 class TemplateParameterList;
 class TypeLoc;
 class UnresolvedSetImpl;
+class VarTemplateDecl;
 
 /// \brief A container of type source information.
 ///
 /// A client can read the relevant info using TypeLoc wrappers, e.g:
 /// @code
-/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
+/// TypeLoc TL = TypeSourceInfo->TypeLoc();
 /// if (PointerLoc *PL = dyn_cast<PointerLoc>(&TL))
 ///   PL->getStarLoc().print(OS, SrcMgr);
 /// @endcode

     unsigned IsConstexpr : 1;
   };
   enum { NumVarDeclBits = 12 };
   
   friend class ASTDeclReader;
   friend class StmtIteratorBase;
+  friend class ASTNodeImporter;
 
 protected:
   enum { NumParameterIndexBits = 8 };

 
   VarDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
           SourceLocation IdLoc, IdentifierInfo *Id,
-          QualType T, TypeSourceInfo *TInfo, StorageClass SC)
-    : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc), Init() {
-    assert(sizeof(VarDeclBitfields) <= sizeof(unsigned));
-    assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned));
-    AllBits = 0;
-    VarDeclBits.SClass = SC;
-    // Everything else is implicitly initialized to false.
-  }
+          QualType T, TypeSourceInfo *TInfo, StorageClass SC,
+          VarDecl *PrevDecl);
 
   typedef Redeclarable<VarDecl> redeclarable_base;
   virtual VarDecl *getNextRedeclaration() { return RedeclLink.getNext(); }

   static VarDecl *Create(ASTContext &C, DeclContext *DC,
                          SourceLocation StartLoc, SourceLocation IdLoc,
                          IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
-                         StorageClass S);
+                         StorageClass S, VarDecl *PrevDecl=0);
 
   static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
   

 
   /// isFileVarDecl - Returns true for file scoped variable declaration.
   bool isFileVarDecl() const {
-    if (getKind() != Decl::Var)
+    Kind k = getKind();
+    if ((k == ParmVar) || (k == ImplicitParam))
       return false;
 
     if (getDeclContext()->getRedeclContext()->isFileContext())

   void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
                         SourceLocation PointOfInstantiation = SourceLocation());
 
+  /// \brief Specify that this variable is an instantiation of the
+  /// static data member VD.
+  void setInstantiationOfStaticDataMember(VarDecl *VD,
+                                     TemplateSpecializationKind TSK);
+
+  /// \brief Retrieves the variable template that is described by this
+  /// variable declaration.
+  ///
+  /// Every variable template is represented as a VarTemplateDecl and a
+  /// VarDecl. The former contains template properties (such as
+  /// the template parameter lists) while the latter contains the
+  /// actual description of the template's
+  /// contents. VarTemplateDecl::getTemplatedDecl() retrieves the
+  /// VarDecl that from a VarTemplateDecl, while
+  /// getDescribedVarTemplate() retrieves the VarTemplateDecl from
+  /// a VarDecl.
+  VarTemplateDecl *getDescribedVarTemplate() const;
+
+  void setDescribedVarTemplate(VarTemplateDecl *Template);
+  
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }

   ImplicitParamDecl(DeclContext *DC, SourceLocation IdLoc,
                     IdentifierInfo *Id, QualType Type)
     : VarDecl(ImplicitParam, DC, IdLoc, IdLoc, Id, Type,
-              /*tinfo*/ 0, SC_None) {
+              /*tinfo*/ 0, SC_None, 0) {
     setImplicit();
   }
 

               SourceLocation IdLoc, IdentifierInfo *Id,
               QualType T, TypeSourceInfo *TInfo,
               StorageClass S, Expr *DefArg)
-    : VarDecl(DK, DC, StartLoc, IdLoc, Id, T, TInfo, S) {
+    : VarDecl(DK, DC, StartLoc, IdLoc, Id, T, TInfo, S, 0) {
+    // Function parameters cannot be variable templates. Hence, PrevDecl=0.
     assert(ParmVarDeclBits.HasInheritedDefaultArg == false);
     assert(ParmVarDeclBits.IsKNRPromoted == false);
     assert(ParmVarDeclBits.IsObjCMethodParam == false);

include/clang/AST/DeclTemplate.h

 class NonTypeTemplateParmDecl;
 class TemplateTemplateParmDecl;
 class TypeAliasTemplateDecl;
+class VarTemplateDecl;
+class VarTemplatePartialSpecializationDecl;
 
 /// \brief Stores a template parameter of any kind.
 typedef llvm::PointerUnion3<TemplateTypeParmDecl*, NonTypeTemplateParmDecl*,

 inline AnyFunctionDecl::AnyFunctionDecl(FunctionTemplateDecl *FTD)
   : Function(FTD) { }
 
+
+/// \brief Represents a variable template specialization, which refers to
+/// a variable template with a given set of template arguments.
+///
+/// Variable template specializations represent both explicit
+/// specialization of variable templates, as in the example below, and
+/// implicit instantiations of variable templates.
+///
+/// \code
+/// template<typename T> constexpr T pi = T(3.1415926535897932385);
+///
+/// template<>
+/// constexpr float pi<float>; // variable template specialization pi<float>
+/// \endcode
+class VarTemplateSpecializationDecl
+  : public VarDecl, public llvm::FoldingSetNode {
+
+  /// \brief Structure that stores information about a variable template
+  /// specialization that was instantiated from a variable template partial
+  /// specialization.
+  struct SpecializedPartialSpecialization {
+    /// \brief The variable template partial specialization from which this
+    /// variable template specialization was instantiated.
+    VarTemplatePartialSpecializationDecl *PartialSpecialization;
+
+    /// \brief The template argument list deduced for the variable template
+    /// partial specialization itself.
+    TemplateArgumentList *TemplateArgs;
+  };
+
+  /// \brief The template that this specialization specializes
+  llvm::PointerUnion<VarTemplateDecl *, SpecializedPartialSpecialization *>
+    SpecializedTemplate;
+
+  /// \brief Further info for explicit template specialization/instantiation.
+  struct ExplicitSpecializationInfo {
+    /// \brief The type-as-written.
+    TypeSourceInfo *TypeAsWritten;
+    /// \brief The location of the extern keyword.
+    SourceLocation ExternLoc;
+    /// \brief The location of the template keyword.
+    SourceLocation TemplateKeywordLoc;
+
+    ExplicitSpecializationInfo()
+      : TypeAsWritten(0), ExternLoc(), TemplateKeywordLoc() {}
+  };
+
+  /// \brief Further info for explicit template specialization/instantiation.
+  /// Does not apply to implicit specializations.
+  ExplicitSpecializationInfo *ExplicitInfo;
+
+  /// \brief The template arguments used to describe this specialization.
+  TemplateArgumentList *TemplateArgs;
+  TemplateArgumentListInfo TemplateArgsInfo;
+
+  /// \brief The point where this template was instantiated (if any)
+  SourceLocation PointOfInstantiation;
+
+  /// \brief The kind of specialization this declaration refers to.
+  /// Really a value of type TemplateSpecializationKind.
+  unsigned SpecializationKind : 3;
+
+protected:
+  VarTemplateSpecializationDecl(ASTContext &Context, Kind DK,
+                                  DeclContext *DC, SourceLocation StartLoc,
+                                  SourceLocation IdLoc,
+                                  VarTemplateDecl *SpecializedTemplate,
+                                  QualType T, TypeSourceInfo *TInfo,
+                                  StorageClass S,
+                                  const TemplateArgument *Args,
+                                  unsigned NumArgs,
+                                  VarTemplateSpecializationDecl *PrevDecl);
+
+  explicit VarTemplateSpecializationDecl(Kind DK);
+
+public:
+  static VarTemplateSpecializationDecl *
+  Create(ASTContext &Context, DeclContext *DC,
+         SourceLocation StartLoc, SourceLocation IdLoc,
+         VarTemplateDecl *SpecializedTemplate,
+         QualType T, TypeSourceInfo *TInfo,
+         StorageClass S,
+         const TemplateArgument *Args,
+         unsigned NumArgs,
+         VarTemplateSpecializationDecl *PrevDecl);
+  static VarTemplateSpecializationDecl *
+  CreateDeserialized(ASTContext &C, unsigned ID);
+
+  virtual void getNameForDiagnostic(raw_ostream &OS,
+                                    const PrintingPolicy &Policy,
+                                    bool Qualified) const;
+
+  VarTemplateSpecializationDecl *getMostRecentDecl() {
+    VarDecl *Recent
+        = cast<VarDecl>(VarDecl::getMostRecentDecl());
+    return cast<VarTemplateSpecializationDecl>(Recent);
+  }
+
+  /// \brief Retrieve the template that this specialization specializes.
+  VarTemplateDecl *getSpecializedTemplate() const;
+
+  /// \brief Retrieve the template arguments of the variable template
+  /// specialization.
+  const TemplateArgumentList &getTemplateArgs() const {
+    return *TemplateArgs;
+  }
+
+  // TODO: Always set this when creating the new specialization?
+  void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo);
+  
+  const TemplateArgumentListInfo &getTemplateArgsInfo() const {
+    return TemplateArgsInfo;
+  }
+
+  /// \brief Determine the kind of specialization that this
+  /// declaration represents.
+  TemplateSpecializationKind getSpecializationKind() const {
+    return static_cast<TemplateSpecializationKind>(SpecializationKind);
+  }
+
+  bool isExplicitSpecialization() const {
+    return getSpecializationKind() == TSK_ExplicitSpecialization;
+  }
+
+  /// \brief True if this declaration is an explicit specialization,
+  /// explicit instantiation declaration, or explicit instantiation
+  /// definition.
+  bool isExplicitInstantiationOrSpecialization() const {
+    switch (getTemplateSpecializationKind()) {
+    case TSK_ExplicitSpecialization:
+    case TSK_ExplicitInstantiationDeclaration:
+    case TSK_ExplicitInstantiationDefinition:
+      return true;
+
+    case TSK_Undeclared:
+    case TSK_ImplicitInstantiation:
+      return false;
+    }
+    llvm_unreachable("bad template specialization kind");
+  }
+
+  void setSpecializationKind(TemplateSpecializationKind TSK) {
+    SpecializationKind = TSK;
+  }
+
+  /// \brief Get the point of instantiation (if any), or null if none.
+  SourceLocation getPointOfInstantiation() const {
+    return PointOfInstantiation;
+  }
+
+  void setPointOfInstantiation(SourceLocation Loc) {
+    assert(Loc.isValid() && "point of instantiation must be valid!");
+    PointOfInstantiation = Loc;
+  }
+
+  /// \brief If this variable template specialization is an instantiation of
+  /// a template (rather than an explicit specialization), return the
+  /// variable template or variable template partial specialization from which it
+  /// was instantiated.
+  llvm::PointerUnion<VarTemplateDecl *,
+                     VarTemplatePartialSpecializationDecl *>
+  getInstantiatedFrom() const {
+    if (getSpecializationKind() != TSK_ImplicitInstantiation &&
+        getSpecializationKind() != TSK_ExplicitInstantiationDefinition &&
+        getSpecializationKind() != TSK_ExplicitInstantiationDeclaration)
+      return llvm::PointerUnion<VarTemplateDecl *,
+                                VarTemplatePartialSpecializationDecl *>();
+
+    if (SpecializedPartialSpecialization *PartialSpec
+          = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
+      return PartialSpec->PartialSpecialization;
+
+    return SpecializedTemplate.get<VarTemplateDecl*>();
+  }
+
+  /// \brief Retrieve the variable template or variable template partial
+  /// specialization which was specialized by this.
+  llvm::PointerUnion<VarTemplateDecl *,
+                     VarTemplatePartialSpecializationDecl *>
+  getSpecializedTemplateOrPartial() const {
+    if (SpecializedPartialSpecialization *PartialSpec
+          = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
+      return PartialSpec->PartialSpecialization;
+
+    return SpecializedTemplate.get<VarTemplateDecl*>();
+  }
+
+  /// \brief Retrieve the set of template arguments that should be used
+  /// to instantiate members of the variable template or variable template partial
+  /// specialization from which this variable template specialization was
+  /// instantiated.
+  ///
+  /// \returns For a variable template specialization instantiated from the primary
+  /// template, this function will return the same template arguments as
+  /// getTemplateArgs(). For a variable template specialization instantiated from
+  /// a variable template partial specialization, this function will return the
+  /// deduced template arguments for the variable template partial specialization
+  /// itself.
+  const TemplateArgumentList &getTemplateInstantiationArgs() const {
+    if (SpecializedPartialSpecialization *PartialSpec
+        = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
+      return *PartialSpec->TemplateArgs;
+
+    return getTemplateArgs();
+  }
+
+  /// \brief Note that this variable template specialization is actually an
+  /// instantiation of the given variable template partial specialization whose
+  /// template arguments have been deduced.
+  void setInstantiationOf(VarTemplatePartialSpecializationDecl *PartialSpec,
+                          TemplateArgumentList *TemplateArgs) {
+    assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
+           "Already set to a variable template partial specialization!");
+    SpecializedPartialSpecialization *PS
+      = new (getASTContext()) SpecializedPartialSpecialization();
+    PS->PartialSpecialization = PartialSpec;
+    PS->TemplateArgs = TemplateArgs;
+    SpecializedTemplate = PS;
+  }
+
+  /// \brief Note that this variable template specialization is an instantiation
+  /// of the given variable template.
+  void setInstantiationOf(VarTemplateDecl *TemplDecl) {
+    assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
+           "Previously set to a variable template partial specialization!");
+    SpecializedTemplate = TemplDecl;
+  }
+
+  /// \brief Sets the type of this specialization as it was written by
+  /// the user. This will be a variable template specialization type.
+  void setTypeAsWritten(TypeSourceInfo *T) {
+    if (!ExplicitInfo)
+      ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
+    ExplicitInfo->TypeAsWritten = T;
+  }
+  /// \brief Gets the type of this specialization as it was written by
+  /// the user, if it was so written.
+  TypeSourceInfo *getTypeAsWritten() const {
+    return ExplicitInfo ? ExplicitInfo->TypeAsWritten : 0;
+  }
+
+  /// \brief Gets the location of the extern keyword, if present.
+  SourceLocation getExternLoc() const {
+    return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
+  }
+  /// \brief Sets the location of the extern keyword.
+  void setExternLoc(SourceLocation Loc) {
+    if (!ExplicitInfo)
+      ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
+    ExplicitInfo->ExternLoc = Loc;
+  }
+
+  /// \brief Sets the location of the template keyword.
+  void setTemplateKeywordLoc(SourceLocation Loc) {
+    if (!ExplicitInfo)
+      ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
+    ExplicitInfo->TemplateKeywordLoc = Loc;
+  }
+  /// \brief Gets the location of the template keyword, if present.
+  SourceLocation getTemplateKeywordLoc() const {
+    return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
+  }
+
+  void Profile(llvm::FoldingSetNodeID &ID) const {
+    Profile(ID, TemplateArgs->data(), TemplateArgs->size(), getASTContext());
+  }
+
+  static void
+  Profile(llvm::FoldingSetNodeID &ID, const TemplateArgument *TemplateArgs,
+          unsigned NumTemplateArgs, ASTContext &Context) {
+    ID.AddInteger(NumTemplateArgs);
+    for (unsigned Arg = 0; Arg != NumTemplateArgs; ++Arg)
+      TemplateArgs[Arg].Profile(ID, Context);
+  }
+
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) {
+    return K >= firstVarTemplateSpecialization &&
+           K <= lastVarTemplateSpecialization;
+  }
+
+  friend class ASTDeclReader;
+  friend class ASTDeclWriter;
+};
+
+class VarTemplatePartialSpecializationDecl
+  : public VarTemplateSpecializationDecl {
+  virtual void anchor();
+
+  /// \brief The list of template parameters
+  TemplateParameterList* TemplateParams;
+
+  /// \brief The source info for the template arguments as written.
+  /// FIXME: redundant with TypeAsWritten?
+  TemplateArgumentLoc *ArgsAsWritten;
+  unsigned NumArgsAsWritten;
+
+  /// \brief Sequence number indicating when this variable template partial
+  /// specialization was added to the set of partial specializations for
+  /// its owning variable template.
+  unsigned SequenceNumber;
+
+  /// \brief The variable template partial specialization from which this
+  /// variable template partial specialization was instantiated.
+  ///
+  /// The boolean value will be true to indicate that this variable template
+  /// partial specialization was specialized at this level.
+  llvm::PointerIntPair<VarTemplatePartialSpecializationDecl *, 1, bool>
+      InstantiatedFromMember;
+
+  VarTemplatePartialSpecializationDecl(ASTContext &Context,
+                                         DeclContext *DC,
+                                         SourceLocation StartLoc,
+                                         SourceLocation IdLoc,
+                                         TemplateParameterList *Params,
+                                         VarTemplateDecl *SpecializedTemplate,
+                                         QualType T, TypeSourceInfo *TInfo,
+                                         StorageClass S,
+                                         const TemplateArgument *Args,
+                                         unsigned NumArgs,
+                                         TemplateArgumentLoc *ArgInfos,
+                                         unsigned NumArgInfos,
+                               VarTemplatePartialSpecializationDecl *PrevDecl,
+                                         unsigned SequenceNumber);
+
+  VarTemplatePartialSpecializationDecl()
+    : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization),
+      TemplateParams(0), ArgsAsWritten(0),
+      NumArgsAsWritten(0), SequenceNumber(0),
+      InstantiatedFromMember(0, false) { }
+
+public:
+  static VarTemplatePartialSpecializationDecl *
+  Create(ASTContext &Context, DeclContext *DC,
+         SourceLocation StartLoc, SourceLocation IdLoc,
+         TemplateParameterList *Params,
+         VarTemplateDecl *SpecializedTemplate,
+         QualType T, TypeSourceInfo *TInfo,
+         StorageClass S,
+         const TemplateArgument *Args,
+         unsigned NumArgs,
+   const TemplateArgumentListInfo &ArgInfos,
+         VarTemplatePartialSpecializationDecl *PrevDecl,
+         unsigned SequenceNumber);
+
+  static VarTemplatePartialSpecializationDecl *
+  CreateDeserialized(ASTContext &C, unsigned ID);
+
+  VarTemplatePartialSpecializationDecl *getMostRecentDecl() {
+    return cast<VarTemplatePartialSpecializationDecl>(
+                   VarTemplateSpecializationDecl::getMostRecentDecl());
+  }
+
+  /// Get the list of template parameters
+  TemplateParameterList *getTemplateParameters() const {
+    return TemplateParams;
+  }
+
+  /// Get the template arguments as written.
+  TemplateArgumentLoc *getTemplateArgsAsWritten() const {
+    return ArgsAsWritten;
+  }
+
+  /// Get the number of template arguments as written.
+  unsigned getNumTemplateArgsAsWritten() const {
+    return NumArgsAsWritten;
+  }
+
+  /// \brief Get the sequence number for this variable template partial
+  /// specialization.
+  unsigned getSequenceNumber() const { return SequenceNumber; }
+
+  /// \brief Retrieve the member variable template partial specialization from
+  /// which this particular variable template partial specialization was
+  /// instantiated.
+  ///
+  /// \code
+  /// template<typename T>
+  /// struct Outer {
+  ///   template<typename U> U Inner;
+  ///   template<typename U> U* Inner<U*> = (U*)(0); // #1
+  /// };
+  ///
+  /// Outer<float>::Inner<int*> ii;
+  /// \endcode
+  ///
+  /// In this example, the instantiation of \c Outer<float>::Inner<int*> will
+  /// end up instantiating the partial specialization
+  /// \c Outer<float>::Inner<U*>, which itself was instantiated from the variable
+  /// template partial specialization \c Outer<T>::Inner<U*>. Given
+  /// \c Outer<float>::Inner<U*>, this function would return
+  /// \c Outer<T>::Inner<U*>.
+  VarTemplatePartialSpecializationDecl *getInstantiatedFromMember() {
+    VarTemplatePartialSpecializationDecl *First
+      = cast<VarTemplatePartialSpecializationDecl>(getFirstDeclaration());
+    return First->InstantiatedFromMember.getPointer();
+  }
+
+  void setInstantiatedFromMember(
+                          VarTemplatePartialSpecializationDecl *PartialSpec) {
+    VarTemplatePartialSpecializationDecl *First
+      = cast<VarTemplatePartialSpecializationDecl>(getFirstDeclaration());
+    First->InstantiatedFromMember.setPointer(PartialSpec);
+  }
+
+  /// \brief Determines whether this variable template partial specialization
+  /// template was a specialization of a member partial specialization.
+  ///
+  /// In the following example, the member template partial specialization
+  /// \c X<int>::Inner<T*> is a member specialization.
+  ///
+  /// \code
+  /// template<typename T>
+  /// struct X {
+  ///   template<typename U> U Inner;
+  ///   template<typename U> U* Inner<U*> = (U*)(0);
+  /// };
+  ///
+  /// template<> template<typename T>
+  /// struct X<int>::Inner<T*> = (T*)(0) + 1;
+  /// \endcode
+  bool isMemberSpecialization() {
+    VarTemplatePartialSpecializationDecl *First
+      = cast<VarTemplatePartialSpecializationDecl>(getFirstDeclaration());
+    return First->InstantiatedFromMember.getInt();
+  }
+
+  /// \brief Note that this member template is a specialization.
+  void setMemberSpecialization() {
+    VarTemplatePartialSpecializationDecl *First
+      = cast<VarTemplatePartialSpecializationDecl>(getFirstDeclaration());
+    assert(First->InstantiatedFromMember.getPointer() &&
+           "Only member templates can be member template specializations");
+    return First->InstantiatedFromMember.setInt(true);
+  }
+
+  // FIXME: Add Profile support!
+
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) {
+    return K == VarTemplatePartialSpecialization;
+  }
+
+  friend class ASTDeclReader;
+  friend class ASTDeclWriter;
+};
+
+/// Declaration of a variable template.
+class VarTemplateDecl : public RedeclarableTemplateDecl {
+  static void DeallocateCommon(void *Ptr);
+
+protected:
+  /// \brief Data that is common to all of the declarations of a given
+  /// variable template.
+  struct Common : CommonBase {
+    Common() : LazySpecializations() { }
+
+    /// \brief The variable template specializations for this class
+    /// template, including explicit specializations and instantiations.
+    llvm::FoldingSetVector<VarTemplateSpecializationDecl> Specializations;
+
+    /// \brief The variable template partial specializations for this class
+    /// template.
+    llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl>
+      PartialSpecializations;
+
+    /// \brief If non-null, points to an array of specializations (including
+    /// partial specializations) known ownly by their external declaration IDs.
+    ///
+    /// The first value in the array is the number of of specializations/
+    /// partial specializations that follow.
+    uint32_t *LazySpecializations;
+  };
+
+  /// \brief Load any lazily-loaded specializations from the external source.
+  void LoadLazySpecializations() const;
+
+  /// \brief Retrieve the set of specializations of this variable template.
+  llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
+  getSpecializations() const;
+
+  /// \brief Retrieve the set of partial specializations of this class
+  /// template.
+  llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
+  getPartialSpecializations();
+
+  VarTemplateDecl(DeclContext *DC, SourceLocation L, DeclarationName Name,
+                    TemplateParameterList *Params, NamedDecl *Decl)
+    : RedeclarableTemplateDecl(VarTemplate, DC, L, Name, Params, Decl) { }
+
+  VarTemplateDecl(EmptyShell Empty)
+    : RedeclarableTemplateDecl(VarTemplate, 0, SourceLocation(),
+                               DeclarationName(), 0, 0) { }
+
+  CommonBase *newCommon(ASTContext &C) const;
+
+  Common *getCommonPtr() const {
+    return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
+  }
+
+public:
+  /// \brief Get the underlying class declarations of the template.
+  VarDecl *getTemplatedDecl() const {
+    return static_cast<VarDecl *>(TemplatedDecl);
+  }
+
+  /// \brief Returns whether this template declaration defines the primary
+  /// class pattern.
+  bool isThisDeclarationADefinition() const {
+    return getTemplatedDecl()->isThisDeclarationADefinition();
+  }
+
+  /// \brief Create a variable template node.
+  static VarTemplateDecl *Create(ASTContext &C, DeclContext *DC,
+                                   SourceLocation L,
+                                   DeclarationName Name,
+                                   TemplateParameterList *Params,
+                                   NamedDecl *Decl,
+                                   VarTemplateDecl *PrevDecl);
+
+  /// \brief Create an empty variable template node.
+  static VarTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
+
+  /// \brief Return the specialization with the provided arguments if it exists,
+  /// otherwise return the insertion point.
+  VarTemplateSpecializationDecl *
+  findSpecialization(const TemplateArgument *Args, unsigned NumArgs,
+                     void *&InsertPos);
+
+  /// \brief Insert the specified specialization knowing that it is not already
+  /// in. InsertPos must be obtained from findSpecialization.
+  void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos);
+
+  VarTemplateDecl *getCanonicalDecl() {
+    return cast<VarTemplateDecl>(
+             RedeclarableTemplateDecl::getCanonicalDecl());
+  }
+  const VarTemplateDecl *getCanonicalDecl() const {
+    return cast<VarTemplateDecl>(
+             RedeclarableTemplateDecl::getCanonicalDecl());
+  }
+
+  /// \brief Retrieve the previous declaration of this variable template, or
+  /// NULL if no such declaration exists.
+  VarTemplateDecl *getPreviousDecl() {
+    return cast_or_null<VarTemplateDecl>(
+             RedeclarableTemplateDecl::getPreviousDecl());
+  }
+
+  /// \brief Retrieve the previous declaration of this variable template, or
+  /// NULL if no such declaration exists.
+  const VarTemplateDecl *getPreviousDecl() const {
+    return cast_or_null<VarTemplateDecl>(
+             RedeclarableTemplateDecl::getPreviousDecl());
+  }
+
+  VarTemplateDecl *getInstantiatedFromMemberTemplate() {
+    return cast_or_null<VarTemplateDecl>(
+             RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
+  }
+
+  /// \brief Return the partial specialization with the provided arguments if it
+  /// exists, otherwise return the insertion point.
+  VarTemplatePartialSpecializationDecl *
+  findPartialSpecialization(const TemplateArgument *Args, unsigned NumArgs,
+                            void *&InsertPos);
+
+  /// \brief Insert the specified partial specialization knowing that it is not
+  /// already in. InsertPos must be obtained from findPartialSpecialization.
+  void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D,
+                                void *InsertPos);
+
+  /// \brief Return the next partial specialization sequence number.
+  unsigned getNextPartialSpecSequenceNumber() {
+    return getPartialSpecializations().size();
+  }
+
+  /// \brief Retrieve the partial specializations as an ordered list.
+  void getPartialSpecializations(
+          SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS);
+
+  /// \brief Find a variable template partial specialization with the given
+  /// type T.
+  ///
+  /// \param T a dependent type that names a specialization of this class
+  /// template.
+  ///
+  /// \returns the variable template partial specialization that exactly matches
+  /// the type \p T, or NULL if no such partial specialization exists.
+  //VarTemplatePartialSpecializationDecl *findPartialSpecialization(QualType T);
+
+  /// \brief Find a variable template partial specialization which was instantiated
+  /// from the given member partial specialization.
+  ///
+  /// \param D a member variable template partial specialization.
+  ///
+  /// \returns the variable template partial specialization which was instantiated
+  /// from the given member partial specialization, or NULL if no such partial
+  /// specialization exists.
+  VarTemplatePartialSpecializationDecl *
+  findPartialSpecInstantiatedFromMember(
+                                     VarTemplatePartialSpecializationDecl *D);
+
+  typedef SpecIterator<VarTemplateSpecializationDecl> spec_iterator;
+
+  spec_iterator spec_begin() const {
+    return makeSpecIterator(getSpecializations(), false);
+  }
+
+  spec_iterator spec_end() const {
+    return makeSpecIterator(getSpecializations(), true);
+  }
+
+  typedef SpecIterator<VarTemplatePartialSpecializationDecl>
+          partial_spec_iterator;
+
+  partial_spec_iterator partial_spec_begin() {
+    return makeSpecIterator(getPartialSpecializations(), false);
+  }
+
+  partial_spec_iterator partial_spec_end() {
+    return makeSpecIterator(getPartialSpecializations(), true);
+  }
+
+  // Implement isa/cast/dyncast support
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) { return K == VarTemplate; }
+
+  friend class ASTDeclReader;
+  friend class ASTDeclWriter;
+};
+
+
 } /* end of namespace clang */
 
 #endif

include/clang/AST/RecursiveASTVisitor.h

   // These are helper methods used by more than one Traverse* method.
   bool TraverseTemplateParameterListHelper(TemplateParameterList *TPL);
   bool TraverseClassInstantiations(ClassTemplateDecl *D);
+  bool TraverseVariableInstantiations(VarTemplateDecl *D);
   bool TraverseFunctionInstantiations(FunctionTemplateDecl *D) ;
   bool TraverseTemplateArgumentLocsHelper(const TemplateArgumentLoc *TAL,
                                           unsigned Count);

     // it was instantiated, and thus should not be traversed.
   })
 
+// A helper method for traversing the implicit instantiations of a
+// variable template.
+template<typename Derived>
+bool RecursiveASTVisitor<Derived>::TraverseVariableInstantiations(
+    VarTemplateDecl *D) {
+  VarTemplateDecl::spec_iterator end = D->spec_end();
+  for (VarTemplateDecl::spec_iterator it = D->spec_begin(); it != end; ++it) {
+    VarTemplateSpecializationDecl* SD = *it;
+
+    switch (SD->getSpecializationKind()) {
+    // Visit the implicit instantiations with the requested pattern.
+    case TSK_Undeclared:
+    case TSK_ImplicitInstantiation:
+      TRY_TO(TraverseDecl(SD));
+      break;
+
+    // We don't need to do anything on an explicit instantiation
+    // or explicit specialization because there will be an explicit
+    // node for it elsewhere.
+    case TSK_ExplicitInstantiationDeclaration:
+    case TSK_ExplicitInstantiationDefinition:
+    case TSK_ExplicitSpecialization:
+      break;
+    }
+  }
+
+  return true;
+}
+
+DEF_TRAVERSE_DECL(VarTemplateDecl, {
+    VarDecl* TempDecl = D->getTemplatedDecl();
+    TRY_TO(TraverseDecl(TempDecl));
+    TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
+
+    // By default, we do not traverse the instantiations of
+    // class templates since they do not appear in the user code. The
+    // following code optionally traverses them.
+    //
+    // We only traverse the class instantiations when we see the canonical
+    // declaration of the template, to ensure we only visit them once.
+    if (getDerived().shouldVisitTemplateInstantiations() &&
+        D == D->getCanonicalDecl())
+      TRY_TO(TraverseVariableInstantiations(D));
+
+    // Note that getInstantiatedFromMemberTemplate() is just a link
+    // from a template instantiation back to the template from which
+    // it was instantiated, and thus should not be traversed.
+  })
+
 // A helper method for traversing the instantiations of a
 // function while skipping its specializations.
 template<typename Derived>

     TRY_TO(TraverseVarHelper(D));
   })
 
+DEF_TRAVERSE_DECL(VarTemplateSpecializationDecl, {
+    // For implicit instantiations, we don't want to
+    // recurse at all, since the instatiated class isn't written in
+    // the source code anywhere.
+    if (TypeSourceInfo *TSI = D->getTypeAsWritten())
+      TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
+
+    if (!getDerived().shouldVisitTemplateInstantiations() &&
+        D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)
+      // Returning from here skips traversing the
+      // declaration context of the VarTemplateSpecializationDecl
+      // (embedded in the DEF_TRAVERSE_DECL() macro).
+      return true;
+  })
+
+DEF_TRAVERSE_DECL(VarTemplatePartialSpecializationDecl, {
+    // The partial specialization.
+    if (TemplateParameterList *TPL = D->getTemplateParameters()) {
+      for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end();
+           I != E; ++I) {
+        TRY_TO(TraverseDecl(*I));
+      }
+    }
+    // The args that remains unspecialized.
+    TRY_TO(TraverseTemplateArgumentLocsHelper(
+        D->getTemplateArgsAsWritten(), D->getNumTemplateArgsAsWritten()));
+
+    // Don't need the VarTemplatePartialSpecializationHelper, even
+    // though that's our parent class -- we already visit all the
+    // template args here.
+    TRY_TO(TraverseVarHelper(D));
+
+    // Instantiations will have been visited with the primary template.
+  })
+
 DEF_TRAVERSE_DECL(ImplicitParamDecl, {
     TRY_TO(TraverseVarHelper(D));
   })

include/clang/Basic/DeclNodes.td

           def CXXDestructor : DDecl<CXXMethod>;
           def CXXConversion : DDecl<CXXMethod>;
       def Var : DDecl<Declarator>;
+        def VarTemplateSpecialization : DDecl<Var>;
+          def VarTemplatePartialSpecialization
+            : DDecl<VarTemplateSpecialization>;
         def ImplicitParam : DDecl<Var>;
         def ParmVar : DDecl<Var>;
       def NonTypeTemplateParm : DDecl<Declarator>;

     def RedeclarableTemplate : DDecl<Template, 1>;
       def FunctionTemplate : DDecl<RedeclarableTemplate>;
       def ClassTemplate : DDecl<RedeclarableTemplate>;
+      def VarTemplate : DDecl<RedeclarableTemplate>;
       def TypeAliasTemplate : DDecl<RedeclarableTemplate>;
     def TemplateTemplateParm : DDecl<Template>;
   def Using : DDecl<Named>;

include/clang/Basic/DiagnosticParseKinds.td

     "definition is meant to be an explicit specialization, add '<>' after the "
     "'template' keyword">;
 def err_template_defn_explicit_instantiation : Error<
-  "%select{function|class}0 cannot be defined in an explicit instantiation; if this "
+  "%select{function|class|variable}0 cannot be defined in an explicit instantiation; if this "
   "declaration is meant to be a %select{function|class}0 definition, remove the 'template' keyword">;
 def err_friend_explicit_instantiation : Error<
   "friend cannot be declared in an explicit instantiation; if this "

include/clang/Basic/DiagnosticSemaKinds.td

 def err_template_typedef : Error<"a typedef cannot be a template">;
 def err_template_unnamed_class : Error<
   "cannot declare a class template with no name">;
+def err_var_template_unnamed_class : Error<
+  "cannot declare a variable template with no name">;
 def err_template_param_list_different_arity : Error<
   "%select{too few|too many}0 template parameters in template "
   "%select{|template parameter }1redeclaration">;

 def err_template_template_parm_no_parms : Error<
   "template template parameter must have its own template parameters">;
 
-def err_template_variable : Error<"variable %0 declared as a template">;
+def ext_template_variable : ExtWarn<"variable %0 declared as a template">, InGroup<CXX1y>;
 def err_template_variable_noparams : Error<
   "extraneous 'template<>' in declaration of variable %0">;
 def err_template_member : Error<"member %0 declared as a template">;

 def err_template_tag_noparams : Error<
   "extraneous 'template<>' in declaration of %0 %1">;
 def err_template_decl_ref : Error<
-  "cannot refer to class template %0 without a template argument list">;
+  "cannot refer to %select{class|variable}0 template %1 without a template argument list">;
 
 // C++ Template Argument Lists
 def err_template_missing_args : Error<

 // C++ template specialization
 def err_template_spec_unknown_kind : Error<
   "can only provide an explicit specialization for a class template, function "
-  "template, or a member function, static data member, "
+  "template, variable template, or a member function, static data member, "
   "%select{or member class|member class, or member enumeration}0 of a "
   "class template">;
 def note_specialized_entity : Note<

 def err_template_spec_decl_friend : Error<
   "cannot declare an explicit specialization in a friend">;
 def err_template_spec_decl_out_of_scope_global : Error<
-  "%select{class template|class template partial|function template|member "
-  "function|static data member|member class|member enumeration}0 "
+  "%select{class template|class template partial|variable template|"
+  "variable template partial|function template|member function|"
+  "static data member|member class|member enumeration}0 "
   "specialization of %1 must originally be declared in the global scope">;
 def err_template_spec_decl_out_of_scope : Error<
-  "%select{class template|class template partial|function template|member "
+  "%select{class template|class template partial|variable template|"
+  "variable template partial|function template|member "
   "function|static data member|member class|member enumeration}0 "
   "specialization of %1 must originally be declared in namespace %2">;
 def ext_template_spec_decl_out_of_scope : ExtWarn<
   "first declaration of %select{class template|class template partial|"
+  "variable template|variable template partial|"
   "function template|member function|static data member|member class|"
   "member enumeration}0 specialization of %1 outside namespace %2 is a "
   "C++11 extension">, InGroup<CXX11>;
 def warn_cxx98_compat_template_spec_decl_out_of_scope : Warning<
-  "%select{class template|class template partial|function template|member "
+  "%select{class template|class template partial|variable template|"
+  "variable template partial|function template|member "
   "function|static data member|member class|member enumeration}0 "
   "specialization of %1 outside namespace %2 is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_template_spec_redecl_out_of_scope : Error<
-  "%select{class template|class template partial|function template|member "
+  "%select{class template|class template partial|variable template|"
+  "variable template partial|function template|member "
   "function|static data member|member class|member enumeration}0 "
   "specialization of %1 not in a namespace enclosing %2">;
 def err_template_spec_redecl_global_scope : Error<
-  "%select{class template|class template partial|function template|member "
+  "%select{class template|class template partial|variable template|"
+  "variable template partial|function template|member "
   "function|static data member|member class|member enumeration}0 "
   "specialization of %1 must occur at global scope">;
 def err_spec_member_not_instantiated : Error<

 def err_template_qualified_declarator_no_match : Error<
   "nested name specifier '%0' for declaration does not refer into a class, "
   "class template or class template partial specialization">;
+def err_var_template_qualified_declarator_no_match : Error<
+  "nested name specifier '%0' for declaration does not refer into a variable, "
+  "variable template or variable template partial specialization">;
 def err_specialize_member_of_template : Error<
   "cannot specialize (with 'template<>') a member of an unspecialized "
   "template">;

   "previous declaration of class template partial specialization %0 is here">;
 def err_partial_spec_fully_specialized : Error<
   "partial specialization of %0 does not use any of its template parameters">;
+
+// C++ Variable Template Partial Specialization
+def err_var_default_arg_in_partial_spec : Error<
+    "default template argument in a variable template partial specialization">;
+def err_var_partial_spec_redeclared : Error<
+  "variable template partial specialization %0 cannot be redeclared">;
+def note_var_prev_partial_spec_here : Note<
+  "previous declaration of variable template partial specialization is here">;
+def err_var_spec_no_template : Error<
+    "no variable template matches %select{|partial}0 specialization">;
   
 // C++ Function template specializations
 def err_function_template_spec_no_match : Error<

   InGroup<CXX11Compat>, DefaultIgnore;
 def err_explicit_instantiation_undefined_member : Error<
   "explicit instantiation of undefined %select{member class|member function|"
-  "static data member}0 %1 of class template %2">;
+  "static data member|static data member template}0 %1 of class template %2">;
 def err_explicit_instantiation_undefined_func_template : Error<
   "explicit instantiation of undefined function template %0">;
+def err_explicit_instantiation_undefined_var_template : Error<
+  "explicit instantiation of undefined variable template %0">;
 def err_explicit_instantiation_declaration_after_definition : Error<
   "explicit instantiation declaration (with 'extern') follows explicit "
   "instantiation definition (without 'extern')">;
 def note_explicit_instantiation_definition_here : Note<
   "explicit instantiation definition is here">;
+def err_invalid_var_template_spec_type : Error<"type %2 "
+  "of %select{explicit instantiation|explicit specialization|"
+  "partial specialization|redeclaration}0 does not match expected type %3">;
   
 // C++ typename-specifiers
 def err_typename_nested_not_found : Error<"no type named %0 in %1">;

 def err_template_id_not_a_type : Error<
   "template name refers to non-type template %0">;
 def note_template_declared_here : Note<
-  "%select{function template|class template|type alias template|template template parameter}0 "
+  "%select{function template|class template|variable template"
+  "|type alias template|template template parameter}0 "
   "%1 declared here">;
 def note_parameter_type : Note<
   "parameter of type %0 is declared here">;

   "definition or redeclaration of %0 not allowed inside a function">;
 def err_not_tag_in_scope : Error<
   "no %select{struct|interface|union|class|enum}0 named %1 in %2">;
+def err_not_var_in_scope : Error<
+  "no variable template named %0 in %1">;
 
 def err_no_typeid_with_fno_rtti : Error<
   "cannot use typeid with -fno-rtti">;

include/clang/Basic/TemplateKinds.h

   /// type. The template itself could be a class template, template
   /// template parameter, or C++0x template alias.
   TNK_Type_template,
+  /// The name refers to a variable template whose specialization produces a
+  /// variable. 
+  TNK_Var_template,
   /// The name refers to a dependent template name. Whether the
   /// template name is assumed to refer to a type template or a
   /// function template depends on the context in which the template

include/clang/Sema/Sema.h

   class ClassTemplateDecl;
   class ClassTemplatePartialSpecializationDecl;
   class ClassTemplateSpecializationDecl;
+  class VarTemplatePartialSpecializationDecl;
   class CodeCompleteConsumer;
   class CodeCompletionAllocator;
   class CodeCompletionTUInfo;

     NC_Expression,
     NC_NestedNameSpecifier,
     NC_TypeTemplate,
+    NC_VarTemplate,
     NC_FunctionTemplate
   };
 

       Result.Template = Name;
       return Result;
     }
+    
+    static NameClassification VarTemplate(TemplateName Name) {
+      NameClassification Result(NC_VarTemplate);
+      Result.Template = Name;
+      return Result;
+    }
 
     static NameClassification FunctionTemplate(TemplateName Name) {
       NameClassification Result(NC_FunctionTemplate);

     }
 
     TemplateName getTemplateName() const {
-      assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate);
+      assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate
+              || Kind == NC_VarTemplate);
       return Template;
     }
 
     TemplateNameKind getTemplateNameKind() const {
-      assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate);
-      return Kind == NC_TypeTemplate? TNK_Type_template : TNK_Function_template;
+      assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate 
+              || Kind == NC_VarTemplate);
+      switch (Kind) {
+      case NC_TypeTemplate:     return TNK_Type_template;
+      case NC_FunctionTemplate: return TNK_Function_template;
+      case NC_VarTemplate:      return TNK_Var_template;
+      default:  llvm_unreachable("unsuported name classification.");
+      }
     }
   };
 

   NamedDecl* ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
                                      TypeSourceInfo *TInfo,
                                      LookupResult &Previous,
-                                     MultiTemplateParamsArg TemplateParamLists);
+                                     MultiTemplateParamsArg TemplateParamLists,
+                                     bool &AddToScope);
   // Returns true if the variable declaration is a redeclaration
   bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
   void CheckVariableDeclarationType(VarDecl *NewVD);

                               ExprValueKind VK,
                               const DeclarationNameInfo &NameInfo,
                               const CXXScopeSpec *SS = 0,
-                              NamedDecl *FoundD = 0);
+                              NamedDecl *FoundD = 0,
+                              const TemplateArgumentListInfo *TemplateArgs = 0);
   ExprResult
   BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS,
                                            SourceLocation nameLoc,

                                       bool NeedsADL);
   ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
                                       const DeclarationNameInfo &NameInfo,
-                                      NamedDecl *D, NamedDecl *FoundD = 0);
+                                      NamedDecl *D, NamedDecl *FoundD = 0,
+                          const TemplateArgumentListInfo *TemplateArgs = 0);
 
   ExprResult BuildLiteralOperatorCall(LookupResult &R,
                                       DeclarationNameInfo &SuffixInfo,

   /// \brief The context in which we are checking a template parameter list.
   enum TemplateParamListContext {
     TPC_ClassTemplate,
+    TPC_VarTemplate,
     TPC_FunctionTemplate,
     TPC_ClassTemplateMember,
     TPC_FriendClassTemplate,

                                     SourceLocation LAngleLoc,
                                     ASTTemplateArgsPtr TemplateArgsIn,
                                     SourceLocation RAngleLoc);
   
-
+  DeclResult ActOnVarTemplateSpecialization(Scope *S,
+                                            VarTemplateDecl *VarTemplate,
+                                            Declarator &D, TypeSourceInfo *DI,
+                                            SourceLocation TemplateKWLoc,
+                                         TemplateParameterList *TemplateParams,
+                                            bool isPartialSpecialization);
+
+  DeclResult CheckVarTemplateId(VarTemplateDecl *Template,
+                                SourceLocation TemplateLoc,
+                                SourceLocation TemplateNameLoc,
+                                const TemplateArgumentListInfo &TemplateArgs);
+  
+  ExprResult CheckVarTemplateId(const CXXScopeSpec &SS,
+                                const DeclarationNameInfo &NameInfo,
+                                VarTemplateDecl *Template,
+                                SourceLocation TemplateLoc,
+                                const TemplateArgumentListInfo *TemplateArgs);
+  
   ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,
                                  SourceLocation TemplateKWLoc,
                                  LookupResult &R,

                           sema::TemplateDeductionInfo &Info);
 
   TemplateDeductionResult
+  DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
+                          const TemplateArgumentList &TemplateArgs,
+                          sema::TemplateDeductionInfo &Info);
+
+  TemplateDeductionResult
   SubstituteExplicitTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
                               TemplateArgumentListInfo &ExplicitTemplateArgs,
                       SmallVectorImpl<DeducedTemplateArgument> &Deduced,

                                   ClassTemplatePartialSpecializationDecl *PS1,
                                   ClassTemplatePartialSpecializationDecl *PS2,
                                   SourceLocation Loc);
+  
+  VarTemplatePartialSpecializationDecl *
+  getMoreSpecializedPartialSpecialization(
+                                  VarTemplatePartialSpecializationDecl *PS1,
+                                  VarTemplatePartialSpecializationDecl *PS2,
+                                  SourceLocation Loc);
 
   void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
                                   bool OnlyDeduced,

                           sema::TemplateDeductionInfo &DeductionInfo,
                           SourceRange InstantiationRange = SourceRange());
 
+    /// \brief Note that we are instantiating as part of template
+    /// argument deduction for a variable template partial
+    /// specialization.
+    InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
+                          VarTemplatePartialSpecializationDecl *PartialSpec,
+                          ArrayRef<TemplateArgument> TemplateArgs,
+                          sema::TemplateDeductionInfo &DeductionInfo,
+                          SourceRange InstantiationRange = SourceRange());
+
     InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
                           ParmVarDecl *Param,
                           ArrayRef<TemplateArgument> TemplateArgs,

                                      FunctionDecl *Function,
                                      bool Recursive = false,
                                      bool DefinitionRequired = false);
+  void InstantiateVariableInitializer(VarDecl* Var, 
+                                      VarDecl* OldVar,
+                      const MultiLevelTemplateArgumentList &TemplateArgs);
+  void InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
+                                     VarDecl *Var,
+                                     bool Recursive = false,
+                                     bool DefinitionRequired = false);
   void InstantiateStaticDataMemberDefinition(
                                      SourceLocation PointOfInstantiation,
                                      VarDecl *Var,

include/clang/Sema/Template.h

                                 ClassTemplatePartialSpecializationDecl *>, 4>
       OutOfLinePartialSpecs;
 
+    /// \brief A list of out-of-line variable template partial
+    /// specializations that will need to be instantiated after the
+    /// enclosing variable's instantiation is complete.
+    SmallVector<std::pair<VarTemplateDecl *,
+                                VarTemplatePartialSpecializationDecl *>, 4>
+      OutOfLineVarPartialSpecs;
+
   public:
     TemplateDeclInstantiator(Sema &SemaRef, DeclContext *Owner,
                              const MultiLevelTemplateArgumentList &TemplateArgs)

         ::iterator
       delayed_partial_spec_iterator;
 
+    typedef 
+      SmallVectorImpl<std::pair<VarTemplateDecl *,
+                                     VarTemplatePartialSpecializationDecl *> >
+        ::iterator
+      delayed_var_partial_spec_iterator;
+    
     /// \brief Return an iterator to the beginning of the set of
     /// "delayed" partial specializations, which must be passed to
     /// InstantiateClassTemplatePartialSpecialization once the class

       return OutOfLinePartialSpecs.begin();
     }
 
+    delayed_var_partial_spec_iterator delayed_var_partial_spec_begin() {
+      return OutOfLineVarPartialSpecs.begin();
+    }
+
     /// \brief Return an iterator to the end of the set of
     /// "delayed" partial specializations, which must be passed to
     /// InstantiateClassTemplatePartialSpecialization once the class

       return OutOfLinePartialSpecs.end();
     }
 
+    delayed_var_partial_spec_iterator delayed_var_partial_spec_end() {
+      return OutOfLineVarPartialSpecs.end();
+    }
+
     // Helper functions for instantiating methods.
     TypeSourceInfo *SubstFunctionType(FunctionDecl *D,
                              SmallVectorImpl<ParmVarDecl *> &Params);

     InstantiateClassTemplatePartialSpecialization(
                                               ClassTemplateDecl *ClassTemplate,
                            ClassTemplatePartialSpecializationDecl *PartialSpec);
+    VarTemplatePartialSpecializationDecl *
+    InstantiateVarTemplatePartialSpecialization(
+                                              VarTemplateDecl *VarTemplate,
+                           VarTemplatePartialSpecializationDecl *PartialSpec);
     void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern);
   };  
 }

include/clang/Serialization/ASTBitCodes.h

       DECL_CLASS_TEMPLATE_SPECIALIZATION,
       /// \brief A ClassTemplatePartialSpecializationDecl record.
       DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION,
+      /// \brief A VarTemplateDecl record.
+      DECL_VAR_TEMPLATE,
+      /// \brief A VarTemplateSpecializationDecl record.
+      DECL_VAR_TEMPLATE_SPECIALIZATION,
+      /// \brief A VarTemplatePartialSpecializationDecl record.
+      DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION,
       /// \brief A FunctionTemplateDecl record.
       DECL_FUNCTION_TEMPLATE,
       /// \brief A TemplateTypeParmDecl record.

include/clang/Serialization/ASTWriter.h

   virtual void AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D);
   virtual void AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD,
                                     const ClassTemplateSpecializationDecl *D);
+  virtual void AddedCXXTemplateSpecialization(const VarTemplateDecl *TD,
+                                    const VarTemplateSpecializationDecl *D);
   virtual void AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
                                               const FunctionDecl *D);
   virtual void DeducedReturnType(const FunctionDecl *FD, QualType ReturnType);

lib/AST/ASTContext.cpp

   return Pos->second;
 }
 
+ASTContext::TemplateOrSpecializationInfo
+ASTContext::getTemplateOrSpecializationInfo(const VarDecl *Var) {
+  llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos
+    = TemplateOrInstantiation.find(Var);
+  if (Pos == TemplateOrInstantiation.end())
+    return TemplateOrSpecializationInfo();
+
+  return Pos->second;
+}
+
 void
 ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,
                                                 TemplateSpecializationKind TSK,
-                                          SourceLocation PointOfInstantiation) {
+            SourceLocation PointOfInstantiation) {
   assert(Inst->isStaticDataMember() && "Not a static data member");
   assert(Tmpl->isStaticDataMember() && "Not a static data member");
   assert(!InstantiatedFromStaticDataMember[Inst] &&
          "Already noted what static data member was instantiated from");
-  InstantiatedFromStaticDataMember[Inst] 
+  InstantiatedFromStaticDataMember[Inst]
     = new (*this) MemberSpecializationInfo(Tmpl, TSK, PointOfInstantiation);
 }
 
+void
+ASTContext::setTemplateOrSpecializationInfo(VarDecl *Inst,
+                                            TemplateOrSpecializationInfo TSI) {
+  assert(!TemplateOrInstantiation[Inst] &&
+         "Already noted what the variable was instantiated from");
+  TemplateOrInstantiation[Inst] = TSI;
+}
+
 FunctionDecl *ASTContext::getClassScopeSpecializationPattern(
                                                      const FunctionDecl *FD){
   assert(FD && "Specialization is 0");

lib/AST/ASTImporter.cpp

 
     bool ImportDefinition(RecordDecl *From, RecordDecl *To, 
                           ImportDefinitionKind Kind = IDK_Default);
+    bool ImportDefinition(VarDecl *From, VarDecl *To, 
+                          ImportDefinitionKind Kind = IDK_Default);
     bool ImportDefinition(EnumDecl *From, EnumDecl *To,
                           ImportDefinitionKind Kind = IDK_Default);
     bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,

                                SmallVectorImpl<TemplateArgument> &ToArgs);
     bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
                            bool Complain = true);
+    bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
+                           bool Complain = true);
     bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
     bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
     bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
+    bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
     Decl *VisitDecl(Decl *D);
     Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
     Decl *VisitNamespaceDecl(NamespaceDecl *D);

     Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
     Decl *VisitClassTemplateSpecializationDecl(
                                             ClassTemplateSpecializationDecl *D);
+    Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
+    Decl *VisitVarTemplateSpecializationDecl(
+                                            VarTemplateSpecializationDecl *D);
                             
     // Importing statements
     Stmt *VisitStmt(Stmt *S);

   return false;
 }
 
+bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To, 
+                                       ImportDefinitionKind Kind) {
+  if (To->getDefinition())
+    return false;
+  
+  // FIXME: Can we really import any initializer? Alternatively, we could force
+  // ourselves to import every declaration of a variable and then only use
+  // getInit() here.
+  To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
+
+  // FIXME: Other bits to merge?
+  
+  return false;
+}
+
 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To, 
                                        ImportDefinitionKind Kind) {
   if (To->getDefinition() || To->isBeingDefined()) {

   return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
 }
 
+bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, 
+                                        VarDecl *ToVar, bool Complain) {
+  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
+                                   Importer.getToContext(),
+                                   Importer.getNonEquivalentDecls(),
+                                   false, Complain);
+  return Ctx.IsStructurallyEquivalent(FromVar, ToVar);
+}
+
+
 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
                                    Importer.getToContext(),

   return Ctx.IsStructurallyEquivalent(From, To);  
 }
 
+bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
+                                        VarTemplateDecl *To) {
+  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
+                                   Importer.getToContext(),
+                                   Importer.getNonEquivalentDecls());
+  return Ctx.IsStructurallyEquivalent(From, To);  
+}
+
 Decl *ASTNodeImporter::VisitDecl(Decl *D) {
   Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
     << D->getDeclKindName();

   LexicalDC->addDeclInternal(ToVar);
 
   // Merge the initializer.
-  // FIXME: Can we really import any initializer? Alternatively, we could force
-  // ourselves to import every declaration of a variable and then only use
-  // getInit() here.
-  ToVar->setInit(Importer.Import(const_cast<Expr *>(D->getAnyInitializer())));
-
-  // FIXME: Other bits to merge?
+  if(ImportDefinition(D, ToVar))
+    return 0;
   
   return ToVar;
 }

   return D2;
 }
 
+Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
+  // If this variable has a definition in the translation unit we're coming from,
+  // but this particular declaration is not that definition, import the
+  // definition and map to that.
+  VarDecl *Definition 
+    = cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
+  if (Definition && Definition != D->getTemplatedDecl()) {
+    Decl *ImportedDef
+      = Importer.Import(Definition->getDescribedVarTemplate());
+    if (!ImportedDef)
+      return 0;
+    
+    return Importer.Imported(D, ImportedDef);
+  }
+  
+  // Import the major distinguishing characteristics of this variable template.
+  DeclContext *DC, *LexicalDC;
+  DeclarationName Name;
+  SourceLocation Loc;
+  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
+    return 0;
+  
+  // We may already have a template of the same name; try to find and match it.
+  if (!DC->isFunctionOrMethod()) {
+    SmallVector<NamedDecl *, 4> ConflictingDecls;
+    SmallVector<NamedDecl *, 2> FoundDecls;
+    DC->localUncachedLookup(Name, FoundDecls);
+    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
+      if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
+        continue;
+      
+      Decl *Found = FoundDecls[I];
+      if (VarTemplateDecl *FoundTemplate 
+                                        = dyn_cast<VarTemplateDecl>(Found)) {
+        if (IsStructuralMatch(D, FoundTemplate)) {
+          // The variable templates structurally match; call it the same template.
+          // FIXME: We may be filling in a forward declaration here. Handle
+          // this case!
+          Importer.Imported(D->getTemplatedDecl(), 
+                            FoundTemplate->getTemplatedDecl());
+          return Importer.Imported(D, FoundTemplate);
+        }         
+      }
+      
+      ConflictingDecls.push_back(FoundDecls[I]);
+    }
+    
+    if (!ConflictingDecls.empty()) {
+      Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
+                                         ConflictingDecls.data(), 
+                                         ConflictingDecls.size());
+    }
+    
+    if (!Name)
+      return 0;
+  }
+
+  VarDecl *DTemplated = D->getTemplatedDecl();
+  
+  // Import the type.
+  QualType T = Importer.Import(DTemplated->getType());
+  if (T.isNull())
+    return 0;
+  
+  // Create the declaration that is being templated.
+  SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
+  SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
+  TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
+  VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(),
+                                          DC, StartLoc, IdLoc,
+                                          Name.getAsIdentifierInfo(),
+                                          T, TInfo,
+                                          DTemplated->getStorageClass());
+  D2Templated->setAccess(DTemplated->getAccess());
+  D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
+  D2Templated->setLexicalDeclContext(LexicalDC);
+  
+  //Importer.Imported(DTemplated, D2Templated);
+  //LexicalDC->addDeclInternal(D2Templated);
+
+  // Merge the initializer.
+  // FIXME: Can we really import any initializer? Alternatively, we could force
+  // ourselves to import every declaration of a variable and then only use
+  // getInit() here.
+  D2Templated->setInit(Importer.Import(
+      const_cast<Expr *>(DTemplated->getAnyInitializer())));
+
+  // FIXME: Other bits to merge?
+  
+  // Create the variable template declaration itself.
+  TemplateParameterList *TemplateParams
+    = ImportTemplateParameterList(D->getTemplateParameters());
+  if (!TemplateParams)
+    return 0;
+  
+  VarTemplateDecl *D2 = VarTemplateDecl::Create(Importer.getToContext(), DC, 
+                                                    Loc, Name, TemplateParams, 
+                                                    D2Templated, 
+                                                    /*PrevDecl=*/0);
+  D2Templated->setDescribedVarTemplate(D2);    
+  
+  D2->setAccess(D->getAccess());
+  D2->setLexicalDeclContext(LexicalDC);
+  LexicalDC->addDeclInternal(D2);
+  
+  // Note the relationship between the variable templates.
+  Importer.Imported(D, D2);
+  Importer.Imported(DTemplated, D2Templated);
+
+  if (DTemplated->isThisDeclarationADefinition() &&
+      !D2Templated->isThisDeclarationADefinition()) {
+    // FIXME: Import definition!
+  }
+  
+  return D2;
+}
+
+Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
+                                          VarTemplateSpecializationDecl *D) {
+  // If this record has a definition in the translation unit we're coming from,
+  // but this particular declaration is not that definition, import the
+  // definition and map to that.
+  VarDecl *Definition = D->getDefinition();
+  if (Definition && Definition != D) {
+    Decl *ImportedDef = Importer.Import(Definition);
+    if (!ImportedDef)
+      return 0;
+    
+    return Importer.Imported(D, ImportedDef);
+  }
+
+  VarTemplateDecl *VarTemplate
+    = cast_or_null<VarTemplateDecl>(Importer.Import(
+                                                 D->getSpecializedTemplate()));
+  if (!VarTemplate)
+    return 0;
+  
+  // Import the context of this declaration.
+  DeclContext *DC = VarTemplate->getDeclContext();
+  if (!DC)
+    return 0;
+  
+  DeclContext *LexicalDC = DC;
+  if (D->getDeclContext() != D->getLexicalDeclContext()) {
+    LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
+    if (!LexicalDC)
+      return 0;
+  }
+  
+  // Import the location of this declaration.
+  SourceLocation StartLoc = Importer.Import(D->getLocStart());
+  SourceLocation IdLoc = Importer.Import(D->getLocation());
+
+  // Import template arguments.
+  SmallVector<TemplateArgument, 2> TemplateArgs;
+  if (ImportTemplateArguments(D->getTemplateArgs().data(), 
+                              D->getTemplateArgs().size(),
+                              TemplateArgs))
+    return 0;
+  
+  // Try to find an existing specialization with these template arguments.
+  void *InsertPos = 0;
+  VarTemplateSpecializationDecl *D2
+    = VarTemplate->findSpecialization(TemplateArgs.data(), 
+                                        TemplateArgs.size(), InsertPos);
+  if (D2) {
+    // We already have a class template specialization with these template
+    // arguments.
+    
+    // FIXME: Check for specialization vs. instantiation errors.
+    
+    if (VarDecl *FoundDef = D2->getDefinition()) {
+      if (!D->isThisDeclarationADefinition() || IsStructuralMatch(D, FoundDef)) {
+        // The record types structurally match, or the "from" translation
+        // unit only had a forward declaration anyway; call it the same
+        // function.
+        return Importer.Imported(D, FoundDef);
+      }
+    }
+  } else {
+    
+    // Import the type.
+    QualType T = Importer.Import(D->getType());
+    if (T.isNull())
+      return 0;
+    TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
+    
+    // Create a new specialization.
+    D2 = VarTemplateSpecializationDecl::Create(Importer.getToContext(), 
+                                                 DC, 
+                                                 StartLoc, IdLoc,
+                                                 VarTemplate,
+                                                 T, TInfo,
+                                                 D->getStorageClass(),
+                                                 TemplateArgs.data(), 
+                                                 TemplateArgs.size(), 
+                                                 /*PrevDecl=*/0);
+    D2->setSpecializationKind(D->getSpecializationKind());
+    D2->setTemplateArgsInfo(D->getTemplateArgsInfo());
+
+    // Add this specialization to the class template.
+    VarTemplate->AddSpecialization(D2, InsertPos);
+    
+    // Import the qualifier, if any.
+    D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
+    
+    // Add the specialization to this context.
+    D2->setLexicalDeclContext(LexicalDC);
+    LexicalDC->addDeclInternal(D2);
+  }
+  Importer.Imported(D, D2);
+  
+  if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2))
+    return 0;
+  
+  return D2;
+}
+
 //----------------------------------------------------------------------------
 // Import Statements
 //----------------------------------------------------------------------------

lib/AST/Decl.cpp

   llvm_unreachable("Invalid storage class");
 }
 
+VarDecl::VarDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
+        SourceLocation IdLoc, IdentifierInfo *Id,
+        QualType T, TypeSourceInfo *TInfo, StorageClass SC,
+        VarDecl *PrevDecl)
+  : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc), Init() {
+  assert(sizeof(VarDeclBitfields) <= sizeof(unsigned));
+  assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned));
+  AllBits = 0;
+  VarDeclBits.SClass = SC;
+  // Everything else is implicitly initialized to false.
+}
+
 VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC,
                          SourceLocation StartL, SourceLocation IdL,
                          IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
-                         StorageClass S) {
-  return new (C) VarDecl(Var, DC, StartL, IdL, Id, T, TInfo, S);
+                         StorageClass S, VarDecl *PrevDecl) {
+  return new (C) VarDecl(Var, DC, StartL, IdL, Id, T, TInfo, S, PrevDecl);
 }
 
 VarDecl *VarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(VarDecl));
   return new (Mem) VarDecl(Var, 0, SourceLocation(), SourceLocation(), 0, 
-                           QualType(), 0, SC_None);
+                           QualType(), 0, SC_None, 0);
 }
 
 void VarDecl::setStorageClass(StorageClass SC) {

 }
 
 TemplateSpecializationKind VarDecl::getTemplateSpecializationKind() const {
+  if (const VarTemplateSpecializationDecl *Spec
+        = dyn_cast<VarTemplateSpecializationDecl>(this))
+    return Spec->getSpecializationKind();
+  
   if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
     return MSI->getTemplateSpecializationKind();
   
   return TSK_Undeclared;
 }
 
+VarTemplateDecl *VarDecl::getDescribedVarTemplate() const {
+  return getASTContext().getTemplateOrSpecializationInfo(this).
+    dyn_cast<VarTemplateDecl*>();
+}
+
+void VarDecl::setDescribedVarTemplate(VarTemplateDecl *Template) {
+  getASTContext().setTemplateOrSpecializationInfo(this, Template);
+}
+
 MemberSpecializationInfo *VarDecl::getMemberSpecializationInfo() const {
+  if (isa<VarTemplateSpecializationDecl>(this))
+    return getASTContext().getTemplateOrSpecializationInfo(this).
+             dyn_cast<MemberSpecializationInfo *>();
+  
   return getASTContext().getInstantiatedFromStaticDataMember(this);
 }
 
 void VarDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
                                          SourceLocation PointOfInstantiation) {
-  MemberSpecializationInfo *MSI = getMemberSpecializationInfo();
-  assert(MSI && "Not an instantiated static data member?");
-  MSI->setTemplateSpecializationKind(TSK);
+  if (VarTemplateSpecializationDecl *Spec
+      = dyn_cast<VarTemplateSpecializationDecl>(this)) {
+    Spec->setSpecializationKind(TSK);
     if (TSK != TSK_ExplicitSpecialization &&
           PointOfInstantiation.isValid() &&
-      MSI->getPointOfInstantiation().isInvalid())
-    MSI->setPointOfInstantiation(PointOfInstantiation);
+          Spec->getPointOfInstantiation().isInvalid())
+        Spec->setPointOfInstantiation(PointOfInstantiation);
+    return; 
+  }
+  
+  if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()){
+    MSI->setTemplateSpecializationKind(TSK);
+    if (TSK != TSK_ExplicitSpecialization &&
+          PointOfInstantiation.isValid() &&
+          MSI->getPointOfInstantiation().isInvalid())
+        MSI->setPointOfInstantiation(PointOfInstantiation);
+    return;
+  }
+  
+  llvm_unreachable("Not a variable or static data member template specialization");
+}
+
+void 
+VarDecl::setInstantiationOfStaticDataMember(VarDecl *VD,
+                                            TemplateSpecializationKind TSK) {
+  assert(getASTContext().getTemplateOrSpecializationInfo(this).isNull() && 
+         "Previous template or instantiation?");
+  assert(!isa<VarTemplateSpecializationDecl>(this));
+  getASTContext().setTemplateOrSpecializationInfo(this,
+    new (getASTContext()) MemberSpecializationInfo(VD, TSK));
 }
 
+
 //===----------------------------------------------------------------------===//
 // ParmVarDecl Implementation
 //===----------------------------------------------------------------------===//

lib/AST/DeclBase.cpp

       return IDNS_Namespace;
 
     case FunctionTemplate:
+    case VarTemplate:
       return IDNS_Ordinary;
 
     case ClassTemplate:

     case ClassTemplateSpecialization:
     case ClassTemplatePartialSpecialization:
     case ClassScopeFunctionSpecialization:
+    case VarTemplateSpecialization:
+    case VarTemplatePartialSpecialization:
     case ObjCImplementation:
     case ObjCCategory:
     case ObjCCategoryImpl:

lib/AST/DeclTemplate.cpp

   return new (Mem) ClassScopeFunctionSpecializationDecl(0, SourceLocation(), 0,
                                              false, TemplateArgumentListInfo());
 }
+
+//===----------------------------------------------------------------------===//
+// VarTemplateDecl Implementation
+//===----------------------------------------------------------------------===//
+
+void VarTemplateDecl::DeallocateCommon(void *Ptr) {
+  static_cast<Common *>(Ptr)->~Common();
+}
+
+VarTemplateDecl *VarTemplateDecl::Create(ASTContext &C,
+                                             DeclContext *DC,
+                                             SourceLocation L,
+                                             DeclarationName Name,
+                                             TemplateParameterList *Params,
+                                             NamedDecl *Decl,
+                                             VarTemplateDecl *PrevDecl) {
+  VarTemplateDecl *New = new (C) VarTemplateDecl(DC, L, Name, Params, Decl);
+  New->setPreviousDeclaration(PrevDecl);
+  return New;
+}
+
+VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C, 
+                                                         unsigned ID) {
+  void *Mem = AllocateDeserializedDecl(C, ID, sizeof(VarTemplateDecl));
+  return new (Mem) VarTemplateDecl(EmptyShell());
+}
+
+void VarTemplateDecl::LoadLazySpecializations() const {
+  Common *CommonPtr = getCommonPtr();
+  if (CommonPtr->LazySpecializations) {
+    ASTContext &Context = getASTContext();
+    uint32_t *Specs = CommonPtr->LazySpecializations;
+    CommonPtr->LazySpecializations = 0;
+    for (uint32_t I = 0, N = *Specs++; I != N; ++I)
+      (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
+  }
+}
+
+llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
+VarTemplateDecl::getSpecializations() const {
+  LoadLazySpecializations();
+  return getCommonPtr()->Specializations;
+}  
+
+llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
+VarTemplateDecl::getPartialSpecializations() {
+  LoadLazySpecializations();
+  return getCommonPtr()->PartialSpecializations;
+}  
+
+RedeclarableTemplateDecl::CommonBase *
+VarTemplateDecl::newCommon(ASTContext &C) const {
+  Common *CommonPtr = new (C) Common;
+  C.AddDeallocation(DeallocateCommon, CommonPtr);
+  return CommonPtr;
+}
+
+VarTemplateSpecializationDecl *
+VarTemplateDecl::findSpecialization(const TemplateArgument *Args,
+                                      unsigned NumArgs, void *&InsertPos) {
+  return findSpecializationImpl(getSpecializations(), Args, NumArgs, InsertPos);
+}
+
+void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D,
+                                          void *InsertPos) {
+  if (InsertPos)
+    getSpecializations().InsertNode(D, InsertPos);
+  else {
+    VarTemplateSpecializationDecl *Existing 
+      = getSpecializations().GetOrInsertNode(D);
+    (void)Existing;
+    assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
+  }
+  if (ASTMutationListener *L = getASTMutationListener())
+    L->AddedCXXTemplateSpecialization(this, D);
+}
+
+VarTemplatePartialSpecializationDecl *
+VarTemplateDecl::findPartialSpecialization(const TemplateArgument *Args,
+                                             unsigned NumArgs,
+                                             void *&InsertPos) {
+  return findSpecializationImpl(getPartialSpecializations(), Args, NumArgs,
+                                InsertPos);
+}
+
+void VarTemplateDecl::AddPartialSpecialization(
+                                      VarTemplatePartialSpecializationDecl *D,
+                                      void *InsertPos) {
+  if (InsertPos)
+    getPartialSpecializations().InsertNode(D, InsertPos);
+  else {
+    VarTemplatePartialSpecializationDecl *Existing
+      = getPartialSpecializations().GetOrInsertNode(D);
+    (void)Existing;
+    assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
+  }
+
+  if (ASTMutationListener *L = getASTMutationListener())
+    L->AddedCXXTemplateSpecialization(this, D);
+}
+
+void VarTemplateDecl::getPartialSpecializations(
+          SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS) {
+  llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs
+    = getPartialSpecializations();
+  PS.clear();
+  PS.resize(PartialSpecs.size());
+  for (llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl>::iterator
+       P = PartialSpecs.begin(), PEnd = PartialSpecs.end();
+       P != PEnd; ++P) {
+    assert(!PS[P->getSequenceNumber()]);
+    PS[P->getSequenceNumber()] = P->getMostRecentDecl();
+  }
+}
+
+VarTemplatePartialSpecializationDecl *
+VarTemplateDecl::findPartialSpecInstantiatedFromMember(
+                                    VarTemplatePartialSpecializationDecl *D) {
+  Decl *DCanon = D->getCanonicalDecl();
+  for (llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl>::iterator
+            P = getPartialSpecializations().begin(),
+         PEnd = getPartialSpecializations().end();
+       P != PEnd; ++P) {
+    if (P->getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
+      return P->getMostRecentDecl();
+  }
+
+  return 0;
+}
+
+//===----------------------------------------------------------------------===//
+// VarTemplateSpecializationDecl Implementation
+//===----------------------------------------------------------------------===//
+VarTemplateSpecializationDecl::
+VarTemplateSpecializationDecl(ASTContext &Context, Kind DK,
+                                DeclContext *DC, SourceLocation StartLoc,
+                                SourceLocation IdLoc,
+                                VarTemplateDecl *SpecializedTemplate,
+                                QualType T, TypeSourceInfo *TInfo,
+                                StorageClass S,
+                                const TemplateArgument *Args,
+                                unsigned NumArgs,
+                                VarTemplateSpecializationDecl *PrevDecl)
+  : VarDecl(DK, DC, StartLoc, IdLoc,
+                  SpecializedTemplate->getIdentifier(),
+                  T, TInfo, S, PrevDecl),
+    SpecializedTemplate(SpecializedTemplate),
+    ExplicitInfo(0),
+    TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args, NumArgs)),
+    SpecializationKind(TSK_Undeclared) {
+}
+
+VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(Kind DK)
+  : VarDecl(DK, 0, SourceLocation(), SourceLocation(), 0, QualType(), 0, SC_None, 0),
+    ExplicitInfo(0),
+    SpecializationKind(TSK_Undeclared) {
+}
+
+VarTemplateSpecializationDecl *
+VarTemplateSpecializationDecl::Create(ASTContext &Context,
+                                        DeclContext *DC,
+                                        SourceLocation StartLoc,
+                                        SourceLocation IdLoc,
+                                        VarTemplateDecl *SpecializedTemplate,
+                                        QualType T, TypeSourceInfo *TInfo,
+                                        StorageClass S,
+                                        const TemplateArgument *Args,
+                                        unsigned NumArgs,
+                                   VarTemplateSpecializationDecl *PrevDecl) {
+  VarTemplateSpecializationDecl *Result
+    = new (Context)VarTemplateSpecializationDecl(Context,
+                                                   VarTemplateSpecialization,
+                                                   DC, StartLoc, IdLoc,
+                                                   SpecializedTemplate,
+                                                   T, TInfo, S,
+                                                   Args, NumArgs,
+                                                   PrevDecl);
+  return Result;
+}
+
+VarTemplateSpecializationDecl *
+VarTemplateSpecializationDecl::CreateDeserialized(ASTContext &C, 
+                                                    unsigned ID) {
+  void *Mem = AllocateDeserializedDecl(C, ID, 
+                                       sizeof(VarTemplateSpecializationDecl));
+  VarTemplateSpecializationDecl *Result =
+    new (Mem) VarTemplateSpecializationDecl(VarTemplateSpecialization);
+  return Result;
+}
+
+void VarTemplateSpecializationDecl::getNameForDiagnostic(
+    raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
+  NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
+
+  const TemplateArgumentList &TemplateArgs = getTemplateArgs();
+  TemplateSpecializationType::PrintTemplateArgumentList(
+      OS, TemplateArgs.data(), TemplateArgs.size(), Policy);
+}
+
+VarTemplateDecl *
+VarTemplateSpecializationDecl::getSpecializedTemplate() const {
+  if (SpecializedPartialSpecialization *PartialSpec
+      = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
+    return PartialSpec->PartialSpecialization->getSpecializedTemplate();
+  return SpecializedTemplate.get<VarTemplateDecl*>();
+}
+
+void
+VarTemplateSpecializationDecl::setTemplateArgsInfo(
+    const TemplateArgumentListInfo &ArgsInfo){
+  unsigned N = ArgsInfo.size();
+  TemplateArgsInfo.setLAngleLoc(ArgsInfo.getLAngleLoc());
+  TemplateArgsInfo.setRAngleLoc(ArgsInfo.getRAngleLoc());
+  for (unsigned I = 0; I != N; ++I)
+    TemplateArgsInfo.addArgument(ArgsInfo[I]);
+}
+
+//===----------------------------------------------------------------------===//
+// VarTemplatePartialSpecializationDecl Implementation
+//===----------------------------------------------------------------------===//
+void VarTemplatePartialSpecializationDecl::anchor() { }
+
+VarTemplatePartialSpecializationDecl::
+VarTemplatePartialSpecializationDecl(ASTContext &Context,
+                                       DeclContext *DC,
+                                       SourceLocation StartLoc,
+                                       SourceLocation IdLoc,
+                                       TemplateParameterList *Params,
+                                       VarTemplateDecl *SpecializedTemplate,
+                                       QualType T, TypeSourceInfo *TInfo,
+                                       StorageClass S,
+                                       const TemplateArgument *Args,
+                                       unsigned NumArgs,
+                                       TemplateArgumentLoc *ArgInfos,
+                                       unsigned NumArgInfos,
+                               VarTemplatePartialSpecializationDecl *PrevDecl,
+                                       unsigned SequenceNumber)
+  : VarTemplateSpecializationDecl(Context,
+                                    VarTemplatePartialSpecialization,
+                                    DC, StartLoc, IdLoc,
+                                    SpecializedTemplate,
+                                    T, TInfo, S,
+                                    Args, NumArgs, PrevDecl),
+    TemplateParams(Params), ArgsAsWritten(ArgInfos),
+    NumArgsAsWritten(NumArgInfos), SequenceNumber(SequenceNumber),
+    InstantiatedFromMember(0, false)
+{ 
+  // FIXME: Is this needed for variable templates?
+  //AdoptTemplateParameterList(Params, this);
+}
+
+VarTemplatePartialSpecializationDecl *
+VarTemplatePartialSpecializationDecl::
+Create(ASTContext &Context, DeclContext *DC,
+       SourceLocation StartLoc, SourceLocation IdLoc,
+       TemplateParameterList *Params,
+       VarTemplateDecl *SpecializedTemplate,
+       QualType T, TypeSourceInfo *TInfo,
+       StorageClass S,
+       const TemplateArgument *Args,
+       unsigned NumArgs,
+       const TemplateArgumentListInfo &ArgInfos,
+       VarTemplatePartialSpecializationDecl *PrevDecl,
+       unsigned SequenceNumber) {
+  unsigned N = ArgInfos.size();
+  TemplateArgumentLoc *ClonedArgs = new (Context) TemplateArgumentLoc[N];
+  for (unsigned I = 0; I != N; ++I)
+    ClonedArgs[I] = ArgInfos[I];
+
+  VarTemplatePartialSpecializationDecl *Result
+    = new (Context)VarTemplatePartialSpecializationDecl(Context, DC,
+                                                          StartLoc, IdLoc,
+                                                          Params,
+                                                          SpecializedTemplate,
+                                                          T, TInfo, S,
+                                                          Args, NumArgs,
+                                                          ClonedArgs, N,
+                                                          PrevDecl,
+                                                          SequenceNumber);
+  Result->setSpecializationKind(TSK_ExplicitSpecialization);
+  return Result;
+}
+
+VarTemplatePartialSpecializationDecl *
+VarTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
+                                                           unsigned ID) {
+  void *Mem = AllocateDeserializedDecl(C, ID, 
+                sizeof(VarTemplatePartialSpecializationDecl));
+  VarTemplatePartialSpecializationDecl *Result
+    = new (Mem) VarTemplatePartialSpecializationDecl();
+  return Result;
+}
+

lib/AST/ItaniumMangle.cpp

     if (DC->isFunctionOrMethod() && D->hasLinkage())
       while (!DC->isNamespace() && !DC->isTranslationUnit())
         DC = getEffectiveParentContext(DC);
-    if (DC->isTranslationUnit() && D->getFormalLinkage() != InternalLinkage)
+    if (DC->isTranslationUnit() && D->getFormalLinkage() != InternalLinkage &&
+        !isa<VarTemplateSpecializationDecl>(D))
       return false;
   }
 

     TemplateArgs = &Spec->getTemplateArgs();
     return Spec->getSpecializedTemplate();
   }
+  
+  // Check if we have a variable template.
+  if (const VarTemplateSpecializationDecl *Spec =
+        dyn_cast<VarTemplateSpecializationDecl>(ND)) {
+    TemplateArgs = &Spec->getTemplateArgs();
+    return Spec->getSpecializedTemplate();
+  }
 
   return 0;
 }

lib/CodeGen/CGDecl.cpp

   case Decl::UnresolvedUsingTypename:
   case Decl::ClassTemplateSpecialization:
   case Decl::ClassTemplatePartialSpecialization:
+  case Decl::VarTemplateSpecialization:
+  case Decl::VarTemplatePartialSpecialization:
   case Decl::TemplateTypeParm:
   case Decl::UnresolvedUsingValue:
   case Decl::NonTypeTemplateParm:

   case Decl::ParmVar:
   case Decl::ImplicitParam:
   case Decl::ClassTemplate:
+  case Decl::VarTemplate:
   case Decl::FunctionTemplate:
   case Decl::TypeAliasTemplate:
   case Decl::TemplateTemplateParm:

lib/CodeGen/CodeGenModule.cpp

 
 StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
   const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
   
   StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()];
   if (!Str.empty())
     return Str;
   
   if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
     IdentifierInfo *II = ND->getIdentifier();
     assert(II && "Attempt to mangle unnamed decl.");

       dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()));
   else
     getCXXABI().getMangleContext().mangleName(ND, Out);
   
   // Allocate space for the mangled name.
   Out.flush();
   size_t Length = Buffer.size();

     EmitGlobalDefinition(GD);
     return;
   }
   
   // If we're deferring emission of a C++ variable with an
   // initializer, remember the order in which it appeared in the file.
   if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&

 
   if (D->hasAttr<AnnotateAttr>())
     AddGlobalAnnotations(D, GV);
   
   GV->setInitializer(Init);
 
   // If it is safe to mark the global 'constant', do so now.

 
     EmitGlobal(cast<FunctionDecl>(D));
     break;
-      
   case Decl::Var:
+    // Skip variable templates
+    if (cast<VarDecl>(D)->getDescribedVarTemplate())
+      return;
+  case Decl::VarTemplateSpecialization:
     EmitGlobal(cast<VarDecl>(D));
     break;
 

   case Decl::UsingShadow:
   case Decl::Using:
   case Decl::ClassTemplate:
+  case Decl::VarTemplate:
+  case Decl::VarTemplatePartialSpecialization:
   case Decl::FunctionTemplate:
   case Decl::TypeAliasTemplate:
   case Decl::Block:

lib/Frontend/MultiplexConsumer.cpp

   virtual void AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D);
   virtual void AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD,
                                     const ClassTemplateSpecializationDecl *D);
+  virtual void AddedCXXTemplateSpecialization(const VarTemplateDecl *TD,
+                                    const VarTemplateSpecializationDecl *D);
   virtual void AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
                                               const FunctionDecl *D);
   virtual void DeducedReturnType(const FunctionDecl *FD, QualType ReturnType);

     Listeners[i]->AddedCXXTemplateSpecialization(TD, D);
 }
 void MultiplexASTMutationListener::AddedCXXTemplateSpecialization(
+    const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) {
+  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
+    Listeners[i]->AddedCXXTemplateSpecialization(TD, D);
+}
+void MultiplexASTMutationListener::AddedCXXTemplateSpecialization(
     const FunctionTemplateDecl *TD, const FunctionDecl *D) {
   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
     Listeners[i]->AddedCXXTemplateSpecialization(TD, D);

lib/Parse/ParseDecl.cpp

     break;
 
   case ParsedTemplateInfo::ExplicitInstantiation: {
-    DeclResult ThisRes
-      = Actions.ActOnExplicitInstantiation(getCurScope(),
-                                           TemplateInfo.ExternLoc,
-                                           TemplateInfo.TemplateLoc,
-                                           D);
-    if (ThisRes.isInvalid()) {
-      SkipUntil(tok::semi, true, true);
-      return 0;
+    if (Tok.is(tok::semi)) {
+      DeclResult ThisRes
+        = Actions.ActOnExplicitInstantiation(getCurScope(),
+                                             TemplateInfo.ExternLoc,
+                                             TemplateInfo.TemplateLoc,
+                                             D);
+      if (ThisRes.isInvalid()) {
+        SkipUntil(tok::semi, true, true);
+        return 0;
+      }
+      ThisDecl = ThisRes.get();
+    } else {
+      // FIXME: This check should be for a variable template instantiation only.
+
+      // Check that this is a valid instantiation
+      if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
+        // If the declarator-id is not a template-id, issue a diagnostic and
+        // recover by ignoring the 'template' keyword.
+        Diag(Tok, diag::err_template_defn_explicit_instantiation) << 2
+            << FixItHint::CreateRemoval(TemplateInfo.TemplateLoc);
+        ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
+      } else {
+        SourceLocation LAngleLoc
+          = PP.getLocForEndOfToken(TemplateInfo.TemplateLoc);
+        Diag(D.getIdentifierLoc(), 
+             diag::err_explicit_instantiation_with_definition)
+          << SourceRange(TemplateInfo.TemplateLoc)
+          << FixItHint::CreateInsertion(LAngleLoc, "<>");
+
+        // Recover as if it were an explicit specialization. 
+        TemplateParameterLists FakedParamLists;
+        FakedParamLists.push_back(
+            Actions.ActOnTemplateParameterList(0, SourceLocation(),
+                                               TemplateInfo.TemplateLoc,
+                                               LAngleLoc, 0, 0, LAngleLoc));
+
+        ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
+                                                   FakedParamLists, D);
+      }
     }
-
-    ThisDecl = ThisRes.get();
     break;
     }
   }

   // If a '==' or '+=' is found, suggest a fixit to '='.
   if (isTokenEqualOrEqualTypo()) {
     ConsumeToken();
+
     if (Tok.is(tok::kw_delete)) {
       if (D.isFunctionDeclarator())
         Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)

lib/Parse/ParseTemplate.cpp

         // If the declarator-id is not a template-id, issue a diagnostic and
         // recover by ignoring the 'template' keyword.
         Diag(Tok, diag::err_template_defn_explicit_instantiation) << 0;
-  return ParseFunctionDefinition(DeclaratorInfo, ParsedTemplateInfo(),
-               &LateParsedAttrs);
+        return ParseFunctionDefinition(DeclaratorInfo, ParsedTemplateInfo(),
+                                       &LateParsedAttrs);
       } else {
         SourceLocation LAngleLoc
           = PP.getLocForEndOfToken(TemplateInfo.TemplateLoc);
-        Diag(DeclaratorInfo.getIdentifierLoc(), 
+        Diag(DeclaratorInfo.getIdentifierLoc(),
              diag::err_explicit_instantiation_with_definition)
           << SourceRange(TemplateInfo.TemplateLoc)
           << FixItHint::CreateInsertion(LAngleLoc, "<>");
 
-        // Recover as if it were an explicit specialization. 
+        // Recover as if it were an explicit specialization.
         TemplateParameterLists FakedParamLists;
         FakedParamLists.push_back(
-       Actions.ActOnTemplateParameterList(0, SourceLocation(),
-                  TemplateInfo.TemplateLoc, 
-            LAngleLoc, 0, 0, LAngleLoc));
+            Actions.ActOnTemplateParameterList(0, SourceLocation(),
+                                               TemplateInfo.TemplateLoc,
+                                               LAngleLoc, 0, 0, LAngleLoc));
 
-        return ParseFunctionDefinition(DeclaratorInfo, 
+        return ParseFunctionDefinition(DeclaratorInfo,
                                        ParsedTemplateInfo(&FakedParamLists,
                                            /*isSpecialization=*/true,
                                            /*LastParamListWasEmpty=*/true),

       }
     }
     return ParseFunctionDefinition(DeclaratorInfo, TemplateInfo,
-           &LateParsedAttrs);
+                                   &LateParsedAttrs);
   }
 
   // Parse this declaration.

lib/Parse/Parser.cpp

       return ANK_TemplateName;
     }
     // Fall through.
+  case Sema::NC_VarTemplate:
   case Sema::NC_FunctionTemplate: {
     // We have a type or function template followed by '<'.
     ConsumeToken();

       AnnotateTemplateIdTokenAsType();
       return false;
     }
+    else if (TemplateId->Kind == TNK_Var_template)
+      return false;
   }
 
   if (SS.isEmpty())

lib/Sema/SemaDecl.cpp

     
     if (!Result.empty()) {
       bool IsFunctionTemplate;
+      bool IsVarTemplate;
       TemplateName Template;
       if (Result.end() - Result.begin() > 1) {
         IsFunctionTemplate = true;

         TemplateDecl *TD
           = cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl());
         IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
+        IsVarTemplate = isa<VarTemplateDecl>(TD);
         
         if (SS.isSet() && !SS.isInvalid())
           Template = Context.getQualifiedTemplateName(SS.getScopeRep(), 

         return NameClassification::FunctionTemplate(Template);
       }
       
-      return NameClassification::TypeTemplate(Template);
+      return IsVarTemplate? NameClassification::VarTemplate(Template)
+              : NameClassification::TypeTemplate(Template);
     }
   }
 

       New->isThisDeclarationADefinition() == VarDecl::Definition &&
       (Def = Old->getDefinition())) {
     Diag(New->getLocation(), diag::err_redefinition)
-      << New->getDeclName();
+      << New;
     Diag(Def->getLocation(), diag::note_previous_definition);
     New->setInvalidDecl();
     return;

                                   AddToScope);
   } else {
     New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous,
-                                  TemplateParamLists);
+                                  TemplateParamLists, 
+                                  AddToScope);
   }
 
   if (New == 0)

 NamedDecl*
 Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
                               TypeSourceInfo *TInfo, LookupResult &Previous,
-                              MultiTemplateParamsArg TemplateParamLists) {
+                              MultiTemplateParamsArg TemplateParamLists,
+                              bool &AddToScope) {
   QualType R = TInfo->getType();
   DeclarationName Name = GetNameForDeclarator(D).getName();
 

   }
 
   bool isExplicitSpecialization = false;
+  bool isVariableTemplateSpecialization = false;
+  bool isPartialSpecialization = false;
+  bool Invalid = false;
+  TemplateParameterList *TemplateParams = 0;
+  VarTemplateDecl *PrevVarTemplate = 0;
   VarDecl *NewVD;
   if (!getLangOpts().CPlusPlus) {
     NewVD = VarDecl::Create(Context, DC, D.getLocStart(),

 
     // Match up the template parameter lists with the scope specifier, then
     // determine whether we have a template or a template specialization.
-    isExplicitSpecialization = false;
-    bool Invalid = false;
-    if (TemplateParameterList *TemplateParams
+    TemplateParams
         = MatchTemplateParametersToScopeSpecifier(
                                   D.getDeclSpec().getLocStart(),
                                                   D.getIdentifierLoc(),

                                                   TemplateParamLists.size(),
                                                   /*never a friend*/ false,
                                                   isExplicitSpecialization,
-                                                  Invalid)) {
-      if (TemplateParams->size() > 0) {
-        // There is no such thing as a variable template.
-        Diag(D.getIdentifierLoc(), diag::err_template_variable)
-          << II
-          << SourceRange(TemplateParams->getTemplateLoc(),
-                         TemplateParams->getRAngleLoc());
-        return 0;
+                                                  Invalid);
+    if (TemplateParams) {
+      if (!getLangOpts().CPlusPlus1y) {
+        if (TemplateParams->size() > 0) {
+          // There is no such thing as a variable template.
+          Diag(D.getIdentifierLoc(), diag::ext_template_variable)
+            << II
+            << SourceRange(TemplateParams->getTemplateLoc(),
+                           TemplateParams->getRAngleLoc());
+          return 0;
+        } else {
+          // There is an extraneous 'template<>' for this variable. Complain
+          // about it, but allow the declaration of the variable.
+          Diag(TemplateParams->getTemplateLoc(),
+               diag::err_template_variable_noparams)
+            << II
+            << SourceRange(TemplateParams->getTemplateLoc(),
+                           TemplateParams->getRAngleLoc());
+        }
       } else {
-        // There is an extraneous 'template<>' for this variable. Complain
-        // about it, but allow the declaration of the variable.
-        Diag(TemplateParams->getTemplateLoc(),
-             diag::err_template_variable_noparams)
-          << II
-          << SourceRange(TemplateParams->getTemplateLoc(),
-                         TemplateParams->getRAngleLoc());
+        NamedDecl *PrevDecl = 0;
+        if (Previous.begin() != Previous.end())
+            PrevDecl = (*Previous.begin())->getUnderlyingDecl();
+        PrevVarTemplate = dyn_cast_or_null<VarTemplateDecl>(PrevDecl);
+
+        if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
+          // This is an explicit specialization.
+          isVariableTemplateSpecialization = true;
+          isPartialSpecialization = TemplateParams->size() > 0;
+
+        } else if (TemplateParams->size() > 0) {
+          // C++1y supports variable templates (N3651).
+          // This is a template declaration.
+
+          // Check that we can declare a template here.
+          if (CheckTemplateDeclScope(S, TemplateParams))
+            return 0;
+
+          // If there is a previous declaration with the same name, check
+          // whether this is a valid redeclaration.
+          if (PrevDecl && !isDeclInScope(PrevDecl, DC, S))
+            PrevDecl = PrevVarTemplate = 0;
+          
+          if (PrevVarTemplate) {
+            // Ensure that the template parameter lists are compatible. 
+            if (!TemplateParameterListsAreEqual(TemplateParams,
+                                       PrevVarTemplate->getTemplateParameters(),
+                                                /*Complain=*/true,
+                                                TPL_TemplateMatch))
+              return 0;
+          } else if (PrevDecl && PrevDecl->isTemplateParameter()) {
+            // Maybe we will complain about the shadowed template parameter.
+            DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
+            
+            // Just pretend that we didn't see the previous declaration.
+            PrevDecl = 0;
+          } else if (PrevDecl) {
+            // C++ [temp]p5:
+            // ... a template name declared in namespace scope or in class
+            // scope shall be unique in that scope.
+            Diag(D.getIdentifierLoc(), 
+                 diag::err_redefinition_different_kind) << Name;
+            Diag(PrevDecl->getLocation(), diag::note_previous_definition);
+            return 0;
+          }
+
+          // Check the template parameter list of this declaration, possibly
+          // merging in the template parameter list from the previous variable
+          // template declaration.
+          if (CheckTemplateParameterList(TemplateParams,
+                PrevVarTemplate? PrevVarTemplate->getTemplateParameters() : 0,
+                                         ( D.getCXXScopeSpec().isSet() && DC &&
+                                          DC->isRecord() &&
+                                          DC->isDependentContext())
+                                           ? TPC_ClassTemplateMember
+                                           : TPC_VarTemplate))
+            Invalid = true;
+
+          if ( D.getCXXScopeSpec().isSet()) {
+            // If the name of the template was qualified, we must be defining the
+            // template out-of-line.
+            if (! D.getCXXScopeSpec().isInvalid() && !Invalid && !PrevVarTemplate) {
+              Diag(D.getIdentifierLoc(), diag::err_member_def_does_not_match)
+                << Name << DC << D.getCXXScopeSpec().getRange();
+              Invalid = true;
+            }
+          }
+        }
       }
     }
 
-    NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
-                            D.getIdentifierLoc(), II,
-                            R, TInfo, SC);
+    if (isVariableTemplateSpecialization) {
+      if (!PrevVarTemplate) {
+        Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template)
+          << isPartialSpecialization;
+        return 0;
+      }
+      
+      SourceLocation TemplateKWLoc = TemplateParamLists.size() > 0
+        ? TemplateParamLists[0]->getTemplateLoc() : SourceLocation();
+      DeclResult Res = ActOnVarTemplateSpecialization(S, PrevVarTemplate,
+                                                      D, TInfo, TemplateKWLoc,
+                                                      TemplateParams,
+                                                      isPartialSpecialization);
+      if (Res.isInvalid())
+        return 0;
+      NewVD = cast<VarDecl>(Res.get());
+      AddToScope = false;
+    }
+    else
+      NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
+                              D.getIdentifierLoc(), II, R, TInfo, SC,
+                   PrevVarTemplate? PrevVarTemplate->getTemplatedDecl() : 0);
 
     // If this decl has an auto type in need of deduction, make a note of the
     // Decl so we can diagnose uses of it in its own initializer.

 
     SetNestedNameSpecifier(NewVD, D);
 
-    if (TemplateParamLists.size() > 0 && D.getCXXScopeSpec().isSet()) {
+    // FIXME: Do we need D.getCXXScopeSpec().isSet()?
+    if (TemplateParams && TemplateParamLists.size() > 1 &&
+        (!isVariableTemplateSpecialization || D.getCXXScopeSpec().isSet())) {
+      NewVD->setTemplateParameterListsInfo(Context,
+                                           TemplateParamLists.size() - 1,
+                                           TemplateParamLists.data());
+    } else if (isVariableTemplateSpecialization ||
+               (!TemplateParams && TemplateParamLists.size() > 0 &&
+                (D.getCXXScopeSpec().isSet()))) {
       NewVD->setTemplateParameterListsInfo(Context,
                                            TemplateParamLists.size(),
                                            TemplateParamLists.data());

   }
 
   if (D.getDeclSpec().isModulePrivateSpecified()) {
-    if (isExplicitSpecialization)
+    if (isVariableTemplateSpecialization)
+      Diag(NewVD->getLocation(), diag::err_module_private_specialization)
+        << (isPartialSpecialization? 1 : 0)
+        << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
+    else if (isExplicitSpecialization)
       Diag(NewVD->getLocation(), diag::err_module_private_specialization)
         << 2
         << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());

   }
 
   // Diagnose shadowed variables before filtering for scope.
+  // FIXME: Special treatment for static variable template members (?).
   if (!D.getCXXScopeSpec().isSet())
     CheckShadow(S, NewVD, Previous);
 

   // scope and are out-of-semantic-context declarations (if the new
   // declaration has linkage).
   FilterLookupForScope(Previous, DC, S, shouldConsiderLinkage(NewVD),
-                       isExplicitSpecialization);
+                       isExplicitSpecialization ||
+                       isVariableTemplateSpecialization);
   
   if (!getLangOpts().CPlusPlus) {
     D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));

       NewVD->setInvalidDecl();
     }
 
-    D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
+    if (!isVariableTemplateSpecialization) {
+      if (PrevVarTemplate) {
+        LookupResult PrevDecl(*this, GetNameForDeclarator(D),
+                              LookupOrdinaryName, ForRedeclaration);
+        PrevDecl.addDecl(PrevVarTemplate->getTemplatedDecl());
+        D.setRedeclaration(CheckVariableDeclaration(NewVD, PrevDecl));
+      } else
+        D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
+    }
 
     // This is an explicit specialization of a static data member. Check it.
+    // FIXME: Special treatment for static variable template members (?).
     if (isExplicitSpecialization && !NewVD->isInvalidDecl() &&
         CheckMemberSpecialization(NewVD, Previous))
       NewVD->setInvalidDecl();

       isIncompleteDeclExternC(*this, NewVD))
     RegisterLocallyScopedExternCDecl(NewVD, S);
 
+  if (getLangOpts().CPlusPlus1y && TemplateParams &&
+      !isVariableTemplateSpecialization) {
+    // C++1y supports variable templates (N3651)
+    // Create a variable template declaration.
+    
+    VarTemplateDecl *NewTemplate
+      = VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), 
+                                  Name, TemplateParams,
+                                  NewVD, PrevVarTemplate);
+    NewVD->setDescribedVarTemplate(NewTemplate);
+    
+    if (D.getDeclSpec().isModulePrivateSpecified())
+      NewTemplate->setModulePrivate();
+
+    // If we are providing an explicit specialization of a static variable 
+    // template, make a note of that.
+    if (PrevVarTemplate &&
+        PrevVarTemplate->getInstantiatedFromMemberTemplate())
+      PrevVarTemplate->setMemberSpecialization();
+
+    // Set the lexical context of this template
+    NewTemplate->setLexicalDeclContext(CurContext);
+
+    if (PrevVarTemplate)
+      mergeDeclAttributes(NewVD, PrevVarTemplate->getTemplatedDecl());
+
+    AddPushedVisibilityAttribute(NewVD);
+
+    PushOnScopeChains(NewTemplate, S);
+    AddToScope = false;
+    
+    if (Invalid) {
+      NewTemplate->setInvalidDecl();
+      NewVD->setInvalidDecl();
+    }
+
+    ActOnDocumentableDecl(NewTemplate);
+  }
+
   return NewVD;
 }
 

lib/Sema/SemaExpr.cpp

 ExprResult
 Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
                        const DeclarationNameInfo &NameInfo,
-                       const CXXScopeSpec *SS, NamedDecl *FoundD) {
+                       const CXXScopeSpec *SS, NamedDecl *FoundD,
+                       const TemplateArgumentListInfo *TemplateArgs) {
   if (getLangOpts().CUDA)
     if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
       if (const FunctionDecl *Callee = dyn_cast<FunctionDecl>(D)) {

     (CurContext != D->getDeclContext() &&
      D->getDeclContext()->isFunctionOrMethod());
 
-  DeclRefExpr *E = DeclRefExpr::Create(Context,
-                                       SS ? SS->getWithLocInContext(Context)
-                                              : NestedNameSpecifierLoc(),
-                                       SourceLocation(),
-                                       D, refersToEnclosingScope,
-                                       NameInfo, Ty, VK, FoundD);
+  DeclRefExpr *E;
+  if (isa<VarTemplateSpecializationDecl>(D)) {
+    assert(getLangOpts().CPlusPlus1y &&
+           "Variable templates are only supported in C++1y");
 
+    VarTemplateSpecializationDecl *VarSpec
+      = cast<VarTemplateSpecializationDecl>(D);
+    
+    E = DeclRefExpr::Create(Context,
+                            SS ? SS->getWithLocInContext(Context)
+                                : NestedNameSpecifierLoc(),
+                            VarSpec->getTemplateKeywordLoc(),
+                            D, refersToEnclosingScope,
+                            NameInfo.getLoc(), Ty, VK, FoundD, TemplateArgs);
+  } else {
+  E = DeclRefExpr::Create(Context,
+                          SS ? SS->getWithLocInContext(Context)
+                              : NestedNameSpecifierLoc(),
+                          SourceLocation(),
+                          D, refersToEnclosingScope,
+                          NameInfo, Ty, VK, FoundD);
+  }
+  
   MarkDeclRefReferenced(E);
 
   if (getLangOpts().ObjCARCWeak && isa<VarDecl>(D) &&

       }
     }
   }
   
   // This is guaranteed from this point on.
   assert(!R.empty() || ADL);
 

                                              R, TemplateArgs);
   }
 
-  if (TemplateArgs || TemplateKWLoc.isValid())
+  if (TemplateArgs || TemplateKWLoc.isValid()) {
+    
+    // In C++1y, if this is a variable template id, then check it 
+    // in BuildTemplateIdExpr(). 
+    // The single lookup result must be a variable template declaration.
+    if (getLangOpts().CPlusPlus1y &&
+        Id.getKind() == UnqualifiedId::IK_TemplateId && 
+        Id.TemplateId && Id.TemplateId->Kind == TNK_Var_template) 
+      assert(R.getAsSingle<VarTemplateDecl>() && 
+             "There should only be one declartion found.");
+    
     return BuildTemplateIdExpr(SS, TemplateKWLoc, R, ADL, TemplateArgs);
-
+  }
+  
+  // FIXME: Should we be able to deduce variable template arguments here, 
+  // e.g. based on the context of its use? 
+  
   return BuildDeclarationNameExpr(SS, R, ADL);
 }
 

 ExprResult
 Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS,
                                const DeclarationNameInfo &NameInfo,
-                               NamedDecl *D, NamedDecl *FoundD) {
+                               NamedDecl *D, NamedDecl *FoundD,
+                               const TemplateArgumentListInfo *TemplateArgs) {
   assert(D && "Cannot refer to a NULL declaration");
   assert(!isa<FunctionTemplateDecl>(D) &&
          "Cannot refer unambiguously to a function template");

     // Specifically diagnose references to class templates that are missing
     // a template argument list.
     Diag(Loc, diag::err_template_decl_ref)
-      << Template << SS.getRange();
+      << (isa<VarTemplateDecl>(D)? 1 : 0) << Template << SS.getRange();
     Diag(Template->getLocation(), diag::note_template_decl_here);
     return ExprError();
   }

     }
 
     case Decl::Var:
+    case Decl::VarTemplateSpecialization:
+    case Decl::VarTemplatePartialSpecialization:
       // In C, "extern void blah;" is valid and is an r-value.
       if (!getLangOpts().CPlusPlus &&
           !type.hasQualifiers() &&

       break;
     }
 
-    return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS, FoundD);
+    return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS, FoundD, TemplateArgs);
   }
 }
 

              cast<CXXRecordDecl>(DC->getParent())->isLambda())
       ParentDC = DC->getParent()->getParent();
     else {
+      // In C++1y, only diagnose when the variable is not a 
+      // variable specialization.
       if (BuildAndDiagnose)
         diagnoseUncapturableValueReference(*this, Loc, Var, DC);
       return true;

     SourceLocation &old = SemaRef.UndefinedButUsed[Var->getCanonicalDecl()];
     if (old.isInvalid()) old = Loc;
   }
   
   SemaRef.tryCaptureVariable(Var, Loc);
 
   Var->setUsed(true);

 static void DoMarkVarDeclReferenced(Sema &SemaRef, SourceLocation Loc,
                                     VarDecl *Var, Expr *E) {
   Var->setReferenced();
   
-  if (!IsPotentiallyEvaluatedContext(SemaRef))
+  if (/*Var->isUsed(false) ||*/ !IsPotentiallyEvaluatedContext(SemaRef))
     return;
   
+  // FIXME: static data member templates ? 
+  
   // Implicit instantiation of static data members of class templates.
   if (Var->isStaticDataMember() && Var->getInstantiatedFromStaticDataMember()) {
     MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo();

             std::make_pair(Var, PointOfInstantiation));
     }
   }
+  // In C++1y, delay instantiations of variable templates, except for those 
+  // that could be used in a constant expression.
+  else if(isa<VarTemplateSpecializationDecl>(Var)) {
+    assert(SemaRef.getLangOpts().CPlusPlus1y &&
+           "Variable templates are only supported in C++1y");
+    assert(!isa<VarTemplatePartialSpecializationDecl>(Var) && 
+           "Can't instantiate a partial template specialization.");
+    VarTemplateSpecializationDecl *VarSpec = 
+        cast<VarTemplateSpecializationDecl>(Var);
+    if (!Var->getAnyInitializer()) {
+      if (VarSpec->getPointOfInstantiation().isInvalid())
+        VarSpec->setPointOfInstantiation(Loc);
+      SourceLocation PointOfInstantiation = VarSpec->getPointOfInstantiation();
+      
+      if (Var->isUsableInConstantExpressions(SemaRef.Context)) 
+        // Do not defer instantiations of variables which could be used in a
+        // constant expression.
+        SemaRef.InstantiateVariableDefinition(PointOfInstantiation, Var);
+      
+      else { 
+        bool InstantiationDependent = false;
+        const TemplateArgumentListInfo &VarTemplateArgs = VarSpec->getTemplateArgsInfo();
+        if (!TemplateSpecializationType::anyDependentTemplateArguments(
+               VarTemplateArgs, InstantiationDependent))
+          // Do not instantiate those specializations that are still type-dependent.
+          SemaRef.PendingInstantiations.push_back(
+            std::make_pair(Var, PointOfInstantiation));
+      }
+    }
+  }
 
   // Per C++11 [basic.def.odr], a variable is odr-used "unless it satisfies
   // the requirements for appearing in a constant expression (5.19) and, if

   const VarDecl *DefVD;
   if (E && !isa<ParmVarDecl>(Var) &&
       Var->isUsableInConstantExpressions(SemaRef.Context) &&
-      Var->getAnyInitializer(DefVD) && DefVD->checkInitIsICE()) {
+      (Var->getAnyInitializer(DefVD) && DefVD->checkInitIsICE())) {
     if (!Var->getType()->isReferenceType())
       SemaRef.MaybeODRUseExprs.insert(E);
-  } else
+  } else {
     MarkVarDeclODRUsed(SemaRef, Var, Loc);
+  }
 }
 
 /// \brief Mark a variable referenced, and check whether it is odr-used

lib/Sema/SemaTemplate.cpp

 
 #include "TreeTransform.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTConsumer.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"

       R.suppressDiagnostics();
     } else {
       assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||
-             isa<TypeAliasTemplateDecl>(TD));
-      TemplateKind = TNK_Type_template;
+             isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD));
+      TemplateKind = isa<VarTemplateDecl>(TD)? 
+                      TNK_Var_template : TNK_Type_template;
     }
   }
 

   return NewTemplate;
 }
 
+
 /// \brief Diagnose the presence of a default template argument on a
 /// template parameter, which is ill-formed in certain contexts.
 ///

                                             SourceRange DefArgRange) {
   switch (TPC) {
   case Sema::TPC_ClassTemplate:
+  case Sema::TPC_VarTemplate:
   case Sema::TPC_TypeAliasTemplate:
     return false;
 

     //   If a template parameter of a primary class template or alias template
     //   is a template parameter pack, it shall be the last template parameter.
     if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
-        (TPC == TPC_ClassTemplate || TPC == TPC_TypeAliasTemplate)) {
+        (TPC == TPC_ClassTemplate || TPC == TPC_VarTemplate || 
+            TPC == TPC_TypeAliasTemplate)) {
       Diag((*NewParam)->getLocation(),
            diag::err_template_param_pack_must_be_last_template_parameter);
       Invalid = true;

     Diag(Template->getLocation(), diag::note_template_declared_here)
       << (isa<FunctionTemplateDecl>(Template)? 0
           : isa<ClassTemplateDecl>(Template)? 1
-          : isa<TypeAliasTemplateDecl>(Template)? 2
-          : 3)
+          : isa<VarTemplateDecl>(Template)? 2
+          : isa<TypeAliasTemplateDecl>(Template)? 3
+          : 4)
       << Template->getDeclName();
     return;
   }

   return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
 }
 
+                                                                           
+static bool CheckTemplatePartialSpecializationArgs(Sema &S,
+       TemplateParameterList *TemplateParams,
+    SmallVectorImpl<TemplateArgument> &TemplateArgs);
+
+static bool CheckTemplateSpecializationScope(Sema &S,
+                                             NamedDecl *Specialized,
+                                             NamedDecl *PrevDecl,
+                                             SourceLocation Loc,
+                                             bool IsPartialSpecialization);
+
+static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D);
+
+// This adapted from ActOnClassTemplateSpecialization()
+DeclResult
+Sema::ActOnVarTemplateSpecialization(Scope *S,
+                                     VarTemplateDecl *VarTemplate,
+                                     Declarator &D, TypeSourceInfo *DI,
+                                     SourceLocation TemplateKWLoc,
+                                     TemplateParameterList *TemplateParams,
+                                     bool isPartialSpecialization) {
+  assert(VarTemplate && "A variable template id without template?");
+
+  // D must be declarator id.
+  assert(D.getName().getKind() == UnqualifiedId::IK_TemplateId &&
+         "Variable template specialization is declared with a template it.");
+
+  TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
+  SourceLocation TemplateNameLoc = D.getIdentifierLoc();
+  SourceLocation LAngleLoc = TemplateId->LAngleLoc;
+  SourceLocation RAngleLoc = TemplateId->RAngleLoc;
+  ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
+                                     TemplateId->NumArgs);
+  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
+  translateTemplateArguments(TemplateArgsPtr, TemplateArgs);
+  TemplateName Name(VarTemplate);
+
+  // Check for unexpanded parameter packs in any of the template arguments.
+  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
+    if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
+                                        UPPC_PartialSpecialization))
+      return true;
+
+  // Check that the template argument list is well-formed for this
+  // template.
+  SmallVector<TemplateArgument, 4> Converted;
+  if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc,
+                                TemplateArgs, false, Converted))
+    return true;
+
+  // Check that the type of this variable template specialization
+  // matches the expected type.
+  TypeSourceInfo *ExpectedDI;
+  {
+    // Do substitution on the type of the declaration
+    TemplateArgumentList TemplateArgList(TemplateArgumentList::OnStack,
+                                         Converted.data(), Converted.size());
+    InstantiatingTemplate Inst(*this, TemplateKWLoc, VarTemplate);
+    if (Inst)
+      return true;
+    VarDecl *Templated = VarTemplate->getTemplatedDecl();
+    ExpectedDI = SubstType(Templated->getTypeSourceInfo(),
+                           MultiLevelTemplateArgumentList(TemplateArgList),
+                           Templated->getTypeSpecStartLoc(),
+                           Templated->getDeclName());
+  }
+  if (!ExpectedDI)
+    return true;
+
+  // Check the new variable specialization against the parsed input.
+  // (Attributes are merged later below.)
+  // FIXME: Model this against function specializations where 
+  // a new function declaration is checked against the specialization 
+  // as candidate for redefinition... (?)
+  if(!Context.hasSameType(DI->getType(), ExpectedDI->getType())) {
+    unsigned ErrStr = isPartialSpecialization ? 2 : 1;
+    Diag(D.getIdentifierLoc(), diag::err_invalid_var_template_spec_type)
+      << ErrStr << VarTemplate << DI->getType() << ExpectedDI->getType();
+    Diag(VarTemplate->getLocation(), diag::note_template_declared_here)
+      << 2 << VarTemplate->getDeclName();
+    return true;
+  }
+
+  // Find the variable template (partial) specialization declaration that
+  // corresponds to these arguments.
+  if (isPartialSpecialization) {
+    if (CheckTemplatePartialSpecializationArgs(*this,
+                                         VarTemplate->getTemplateParameters(),
+                                         Converted))
+      return true;
+
+    bool InstantiationDependent;
+    if (!Name.isDependent() &&
+        !TemplateSpecializationType::anyDependentTemplateArguments(
+                                             TemplateArgs.getArgumentArray(),
+                                                         TemplateArgs.size(),
+                                                     InstantiationDependent)) {
+      Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
+        << VarTemplate->getDeclName();
+      isPartialSpecialization = false;
+    }
+  }
+
+  void *InsertPos = 0;
+  VarTemplateSpecializationDecl *PrevDecl = 0;
+
+  if (isPartialSpecialization)
+    // FIXME: Template parameter list matters, too
+    PrevDecl
+      = VarTemplate->findPartialSpecialization(Converted.data(),
+                                                 Converted.size(),
+                                                 InsertPos);
+  else
+    PrevDecl
+      = VarTemplate->findSpecialization(Converted.data(),
+                                          Converted.size(), InsertPos);
+
+  VarTemplateSpecializationDecl *Specialization = 0;
+
+  // Check whether we can declare a variable template specialization in
+  // the current scope.
+  if (CheckTemplateSpecializationScope(*this, VarTemplate, PrevDecl,
+                                       TemplateNameLoc,
+                                       isPartialSpecialization))
+    return true;
+
+  if (PrevDecl &&
+      (PrevDecl->getSpecializationKind() == TSK_Undeclared)) {
+    // Since the only prior variable template specialization with these
+    // arguments was referenced but not declared,  reuse that
+    // declaration node as our own, updating its source location and
+    // the list of outer template parameters to reflect our new declaration.
+    Specialization = PrevDecl;
+    Specialization->setLocation(TemplateNameLoc);
+    PrevDecl = 0;
+  } else if (isPartialSpecialization) {
+    // Create a new class template partial specialization declaration node.
+    VarTemplatePartialSpecializationDecl *PrevPartial
+      = cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
+    unsigned SequenceNumber = PrevPartial? PrevPartial->getSequenceNumber()
+                            : VarTemplate->getNextPartialSpecSequenceNumber();
+    VarTemplatePartialSpecializationDecl *Partial
+      = VarTemplatePartialSpecializationDecl::Create(Context,
+                                                 VarTemplate->getDeclContext(),
+                                                     TemplateKWLoc,
+                                                     TemplateNameLoc,
+                                                     TemplateParams, 
+                                                     VarTemplate,
+                                                     DI->getType(), DI,
+                            VarTemplate->getTemplatedDecl()->getStorageClass(),
+                                                     Converted.data(),
+                                                     Converted.size(), 
+                                                     TemplateArgs,
+                                                     PrevPartial,
+                                                     SequenceNumber);
+
+    if (!PrevPartial)
+      VarTemplate->AddPartialSpecialization(Partial, InsertPos);
+    Specialization = Partial;
+
+    // If we are providing an explicit specialization of a member class
+    // template specialization, make a note of that.
+    if (PrevPartial && PrevPartial->getInstantiatedFromMember())
+      PrevPartial->setMemberSpecialization();
+
+    // Check that all of the template parameters of the class template
+    // partial specialization are deducible from the template
+    // arguments. If not, this class template partial specialization
+    // will never be used.
+    llvm::SmallBitVector DeducibleParams(TemplateParams->size());
+    MarkUsedTemplateParameters(Partial->getTemplateArgs(), true,
+                               TemplateParams->getDepth(),
+                               DeducibleParams);
+
+    if (!DeducibleParams.all()) {
+      unsigned NumNonDeducible = DeducibleParams.size()-DeducibleParams.count();
+      Diag(TemplateNameLoc, diag::warn_partial_specs_not_deducible)
+        << (NumNonDeducible > 1)
+        << SourceRange(TemplateNameLoc, RAngleLoc);
+      for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
+        if (!DeducibleParams[I]) {
+          NamedDecl *Param = cast<NamedDecl>(TemplateParams->getParam(I));
+          if (Param->getDeclName())
+            Diag(Param->getLocation(),
+                 diag::note_partial_spec_unused_parameter)
+              << Param->getDeclName();
+          else
+            Diag(Param->getLocation(),
+                 diag::note_partial_spec_unused_parameter)
+              << "<anonymous>";
+        }
+      }
+    }
+  } else {
+    // Create a new class template specialization declaration node for
+    // this explicit specialization or friend declaration.
+    Specialization
+      = VarTemplateSpecializationDecl::Create(Context,
+                                              VarTemplate->getDeclContext(),
+                                              TemplateKWLoc,
+                                              TemplateNameLoc,
+                                              VarTemplate,
+                                              DI->getType(), DI,
+                          VarTemplate->getTemplatedDecl()->getStorageClass(),
+                                              Converted.data(),
+                                              Converted.size(), PrevDecl);
+    Specialization->setTemplateArgsInfo(TemplateArgs);
+    
+    if (!PrevDecl)
+      VarTemplate->AddSpecialization(Specialization, InsertPos);
+  }
+
+  // C++ [temp.expl.spec]p6:
+  //   If a template, a member template or the member of a class template is
+  //   explicitly specialized then that specialization shall be declared
+  //   before the first use of that specialization that would cause an implicit
+  //   instantiation to take place, in every translation unit in which such a
+  //   use occurs; no diagnostic is required.
+  if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
+    bool Okay = false;
+    for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
+      // Is there any previous explicit specialization declaration?
+      if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
+        Okay = true;
+        break;
+      }
+    }
+
+    if (!Okay) {
+      SourceRange Range(TemplateNameLoc, RAngleLoc);
+      Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
+        << Name << Range;
+
+      Diag(PrevDecl->getPointOfInstantiation(),
+           diag::note_instantiation_required_here)
+        << (PrevDecl->getTemplateSpecializationKind()
+                                                != TSK_ImplicitInstantiation);
+      return true;
+    }
+  }
+
+  // Note that this is an explicit specialization.
+  Specialization->setSpecializationKind(TSK_ExplicitSpecialization);
+
+  if(PrevDecl) {
+    // Check that this isn't a redefinition of this specialization, 
+    // merging with previous declarations.
+    LookupResult PrevSpec(*this, GetNameForDeclarator(D),
+                          LookupOrdinaryName, ForRedeclaration);
+    PrevSpec.addDecl(PrevDecl);
+    D.setRedeclaration(CheckVariableDeclaration(Specialization, PrevSpec));
+  }
+
+  Specialization->setTemplateKeywordLoc(TemplateKWLoc);
+
+  // Add the specialization into its lexical context, so that it can
+  // be seen when iterating through the list of declarations in that
+  // context. However, specializations are not found by name lookup.
+  CurContext->addDecl(Specialization);
+
+  return Specialization;
+}
+
+namespace {
+  /// \brief A partial specialization whose template arguments have matched
+  /// a given template-id.
+  struct PartialSpecMatchResult {
+    VarTemplatePartialSpecializationDecl *Partial;
+    TemplateArgumentList *Args;
+  };
+}
+
+// This is adapted from a combination of CheckTemplateIdType() and
+// TemplateDeclInstantiator::VisitVarDecl().
+DeclResult Sema::CheckVarTemplateId(VarTemplateDecl *Template,
+                                    SourceLocation TemplateLoc,
+                                    SourceLocation TemplateNameLoc,
+                                    const TemplateArgumentListInfo &TemplateArgs) {
+  assert(Template && "A variable template id without template?");
+  VarDecl* Templated = Template->getTemplatedDecl();
+  SourceLocation PointOfInstantiation = TemplateNameLoc;
+
+  // Check that the template argument list is well-formed for this
+  // template.
+  SmallVector<TemplateArgument, 4> Converted;
+  bool ExpansionIntoFixedList = false;
+  if (CheckTemplateArgumentList(Template, TemplateNameLoc, 
+                      const_cast<TemplateArgumentListInfo &>(TemplateArgs),
+                                false, Converted, &ExpansionIntoFixedList))
+    return true;
+
+  // Find the variable template specialization declaration that
+  // corresponds to these arguments.
+  void *InsertPos = 0;
+  VarTemplateSpecializationDecl *Decl
+    = Template->findSpecialization(Converted.data(), Converted.size(),
+                                   InsertPos);
+
+  if (!Decl) {
+    // This is the first time we have referenced this variable template
+    // specialization. Create the canonical declaration and add it to
+    // the set of specializations.
+ 
+    // Do substitution on the type of the declaration
+    TemplateArgumentList TemplateArgList(TemplateArgumentList::OnStack,
+                                         Converted.data(), Converted.size());
+    TypeSourceInfo *DI;
+    {
+      InstantiatingTemplate Inst(*this, TemplateLoc, Template);
+      if (Inst)
+        return true;
+      DI = SubstType(Templated->getTypeSourceInfo(),
+                                MultiLevelTemplateArgumentList(TemplateArgList),
+                                     Templated->getTypeSpecStartLoc(),
+                                     Templated->getDeclName());
+    }
+    if (!DI)
+      return true;
+
+    if (DI->getType()->isFunctionType()) {
+      Diag(Templated->getLocation(), 
+           diag::err_variable_instantiates_to_function)
+        << Templated->isStaticDataMember() << DI->getType();
+      return true;
+    }
+
+    Decl = VarTemplateSpecializationDecl::Create(Context,
+                                                 Template->getDeclContext(),
+                                                 Templated->getLocStart(),
+                                                 Template->getLocation(),
+                                                 Template,
+                                                 DI->getType(), DI,
+                                                 Templated->getStorageClass(),
+                                                 Converted.data(),
+                                                 Converted.size(), 0);
+    assert(Decl && "Creating a variable template pecialization failed?");
+
+    Decl->setTemplateArgsInfo(TemplateArgs);
+    Template->AddSpecialization(Decl, InsertPos);
+    if (Template->isOutOfLine())
+      Decl->setLexicalDeclContext(Templated->getLexicalDeclContext());
+    Decl->setTSCSpec(Templated->getTSCSpec());
+    Decl->setInitStyle(Templated->getInitStyle());
+    Decl->setCXXForRangeDecl(Templated->isCXXForRangeDecl());
+    Decl->setConstexpr(Templated->isConstexpr());
+    Decl->setAccess(Templated->getAccess());
+
+    if (!Templated->isStaticDataMember()) {
+      Decl->setUsed(Templated->isUsed(false));
+      Decl->setReferenced(Templated->isReferenced());
+    }
+
+    // FIXME: LateAttrs et al.?
+    InstantiateAttrs(MultiLevelTemplateArgumentList(TemplateArgList), 
+                      Templated, Decl/*, LateAttrs, StartingScope*/);
+
+    if (Decl->hasAttrs())
+      CheckAlignasUnderalignment(Decl);
+
+    // FIXME: having to fake up a LookupResult is dumb.
+    LookupResult Previous(*this, Decl->getDeclName(), Decl->getLocation(),
+                          Sema::LookupOrdinaryName, Sema::ForRedeclaration);
+    if (Templated->isStaticDataMember())
+      LookupQualifiedName(Previous, Templated->getDeclContext(), false);
+
+    CheckVariableDeclaration(Decl, Previous);
+
+    if (Templated->isOutOfLine()) {
+      Templated->getLexicalDeclContext()->addDecl(Decl);
+      Templated->getDeclContext()->makeDeclVisibleInContext(Decl);
+    } else {
+      Templated->getDeclContext()->addDecl(Decl);
+      if (Templated->getDeclContext()->isFunctionOrMethod())
+        CurrentInstantiationScope->InstantiatedLocal(Templated, Decl);
+    }
+
+    // Link instantiations of static data members back to the template from
+    // which they were instantiated.
+    if (Decl->isStaticDataMember())
+      Context.setInstantiatedFromStaticDataMember(Decl, Templated,
+                                                  TSK_ImplicitInstantiation);
+
+    // Attempt to find the closest partial specialization that this
+    // specializes, if any.
+    // If any of the template arguments is dependent, then this is probably
+    // a placeholder for an incomplete declarative context; which must be
+    // be complete by instantiation time. Thus, do search through the partial
+    // specializations yet.
+    // FIXME: Unify with InstantiateClassTemplateSpecialization()?
+    bool InstantiationDependent = false;
+    if (!TemplateSpecializationType::anyDependentTemplateArguments(
+            TemplateArgs, InstantiationDependent)) {
+      typedef PartialSpecMatchResult MatchResult;
+      SmallVector<MatchResult, 4> Matched;
+      SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
+      Template->getPartialSpecializations(PartialSpecs);
+      
+      for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
+        VarTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
+        TemplateDeductionInfo Info(PointOfInstantiation);
+
+        if (TemplateDeductionResult Result
+              = DeduceTemplateArguments(Partial, Decl->getTemplateArgs(),
+                                        Info)) {
+          // FIXME: Store the failed-deduction information for use in
+          // diagnostics, later.
+          (void)Result;
+        } else {
+          Matched.push_back(PartialSpecMatchResult());
+          Matched.back().Partial = Partial;
+          Matched.back().Args = Info.take();
+        }
+      }
+
+      // If we're dealing with a member template where the template parameters
+      // have been instantiated, this provides the original template parameters
+      // from which the member template's parameters were instantiated.
+      SmallVector<const NamedDecl *, 4> InstantiatedTemplateParameters;
+
+      if (Matched.size() >= 1) {
+        SmallVector<MatchResult, 4>::iterator Best = Matched.begin();
+        if (Matched.size() == 1) {
+          //   -- If exactly one matching specialization is found, the
+          //      instantiation is generated from that specialization.
+          // We don't need to do anything for this.
+        } else {
+          //   -- If more than one matching specialization is found, the
+          //      partial order rules (14.5.4.2) are used to determine
+          //      whether one of the specializations is more specialized
+          //      than the others. If none of the specializations is more
+          //      specialized than all of the other matching
+          //      specializations, then the use of the class template is
+          //      ambiguous and the program is ill-formed.
+          for (SmallVector<MatchResult, 4>::iterator P = Best + 1,
+                                                        PEnd = Matched.end();
+               P != PEnd; ++P) {
+            if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
+                                                        PointOfInstantiation) 
+                  == P->Partial)
+              Best = P;
+          }
+
+          // Determine if the best partial specialization is more specialized than
+          // the others.
+          bool Ambiguous = false;
+          for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
+                                                        PEnd = Matched.end();
+               P != PEnd; ++P) {
+            if (P != Best &&
+                getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
+                                                        PointOfInstantiation)
+                  != Best->Partial) {
+              Ambiguous = true;
+              break;
+            }
+          }
+
+          if (Ambiguous) {
+            // Partial ordering did not produce a clear winner. Complain.
+            Decl->setInvalidDecl();
+            Diag(PointOfInstantiation, 
+                 diag::err_partial_spec_ordering_ambiguous) << Decl;
+            
+            // Print the matching partial specializations.
+            for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
+                                                          PEnd = Matched.end();
+                 P != PEnd; ++P)
+              Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
+                << getTemplateArgumentBindingsText(
+                                           P->Partial->getTemplateParameters(),
+                                                   *P->Args);
+            return true;
+          }
+        }
+
+        // Instantiate using the best variable template partial specialization.
+        Decl->setInstantiationOf(Best->Partial, Best->Args);
+      } else {
+        //   -- If no match is found, the instantiation is generated
+        //      from the primary template.
+      }
+    }
+
+    // Do not instantiate the variable just yet. 
+    // Instantiation is handled in DoMarkVarDeclReferenced().
+  }
+
+  assert(Decl && "No variable template specialization?");
+  return Decl;
+}
+
+ExprResult Sema::CheckVarTemplateId(const CXXScopeSpec &SS,
+                                    const DeclarationNameInfo &NameInfo,
+                                    VarTemplateDecl *Template,
+                                    SourceLocation TemplateLoc,
+                              const TemplateArgumentListInfo *TemplateArgs) {
+  DeclResult Decl = CheckVarTemplateId(Template, TemplateLoc,
+                                       NameInfo.getLoc(), *TemplateArgs);
+  if (Decl.isInvalid())
+    return ExprError();
+  
+  //build an ordinary singleton decl ref.
+  return BuildDeclarationNameExpr(SS, NameInfo, cast<NamedDecl>(Decl.get()), 
+                                  /*FoundD=*/0, TemplateArgs);
+}
+
 ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
                                      SourceLocation TemplateKWLoc,
                                      LookupResult &R,

   // These should be filtered out by our callers.
   assert(!R.empty() && "empty lookup results when building templateid");
   assert(!R.isAmbiguous() && "ambiguous lookup when building templateid");
+  
+  // In C++1y, check variable template ids. 
+  if (R.getAsSingle<VarTemplateDecl>()) {
+    assert(getLangOpts().CPlusPlus1y &&
+           "Variable templates are only supported in C++1y");
+    return Owned(CheckVarTemplateId(SS, R.getLookupNameInfo(), 
+                                    R.getAsSingle<VarTemplateDecl>(), 
+                                    TemplateKWLoc, TemplateArgs));
+  }
 
   // We don't want lookup warnings at this point.
   R.suppressDiagnostics();

   int EntityKind = 0;
   if (isa<ClassTemplateDecl>(Specialized))
     EntityKind = IsPartialSpecialization? 1 : 0;
+  else if (isa<VarTemplateDecl>(Specialized))
+    EntityKind = IsPartialSpecialization? 3 : 2;
   else if (isa<FunctionTemplateDecl>(Specialized))
-    EntityKind = 2;
+    EntityKind = 4;
   else if (isa<CXXMethodDecl>(Specialized))
-    EntityKind = 3;
+    EntityKind = 5;
   else if (isa<VarDecl>(Specialized))
-    EntityKind = 4;
+    EntityKind = 6;
   else if (isa<RecordDecl>(Specialized))
-    EntityKind = 5;
+    EntityKind = 7;
   else if (isa<EnumDecl>(Specialized) && S.getLangOpts().CPlusPlus11)
-    EntityKind = 6;
+    EntityKind = 8;
   else {
     S.Diag(Loc, diag::err_template_spec_unknown_kind)
       << S.getLangOpts().CPlusPlus11;

   return false;
 }
 
-/// \brief Subroutine of Sema::CheckClassTemplatePartialSpecializationArgs
+/// \brief Subroutine of Sema::CheckTemplatePartialSpecializationArgs
 /// that checks non-type template partial specialization arguments.
-static bool CheckNonTypeClassTemplatePartialSpecializationArgs(Sema &S,
+static bool CheckNonTypeTemplatePartialSpecializationArgs(Sema &S,
                                                 NonTypeTemplateParmDecl *Param,
                                                   const TemplateArgument *Args,
                                                         unsigned NumArgs) {
   for (unsigned I = 0; I != NumArgs; ++I) {
     if (Args[I].getKind() == TemplateArgument::Pack) {
-      if (CheckNonTypeClassTemplatePartialSpecializationArgs(S, Param,
-                                                           Args[I].pack_begin(),
-                                                           Args[I].pack_size()))
+      if (CheckNonTypeTemplatePartialSpecializationArgs(S, Param,
         return true;
 
       continue;

 /// partial specialization.
 ///
 /// \returns true if there was an error, false otherwise.
-static bool CheckClassTemplatePartialSpecializationArgs(Sema &S,
+static bool CheckTemplatePartialSpecializationArgs(Sema &S,
                                         TemplateParameterList *TemplateParams,
                        SmallVectorImpl<TemplateArgument> &TemplateArgs) {
   const TemplateArgument *ArgList = TemplateArgs.data();

     if (!Param)
       continue;
 
-    if (CheckNonTypeClassTemplatePartialSpecializationArgs(S, Param,
-                                                           &ArgList[I], 1))
+    if (CheckNonTypeTemplatePartialSpecializationArgs(S, Param,
       return true;
   }
 

   // Find the class template (partial) specialization declaration that
   // corresponds to these arguments.
   if (isPartialSpecialization) {
-    if (CheckClassTemplatePartialSpecializationArgs(*this,
+    if (CheckTemplatePartialSpecializationArgs(*this,
                                          ClassTemplate->getTemplateParameters(),
                                          Converted))
       return true;

            diag::err_explicit_instantiation_inline :
            diag::warn_explicit_instantiation_inline_0x)
       << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
-  if (D.getDeclSpec().isConstexprSpecified())
+  if (D.getDeclSpec().isConstexprSpecified() && R->isFunctionType())
     // FIXME: Add a fix-it to remove the 'constexpr' and add a 'const' if one is
     // not already specified.
     Diag(D.getDeclSpec().getConstexprSpecLoc(),

     //   A [...] static data member of a class template can be explicitly
     //   instantiated from the member definition associated with its class
     //   template.
+    // C++1y [temp.explicit]p1:
+    //   A [...] variable [...] template specialization can be explicitly 
+    //   instantiated from its template.
     if (Previous.isAmbiguous())
       return true;
 
     VarDecl *Prev = Previous.getAsSingle<VarDecl>();
-    if (!Prev || !Prev->isStaticDataMember()) {
-      // We expect to see a data data member here.
-      Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
-        << Name;
-      for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
-           P != PEnd; ++P)
-        Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
-      return true;
+    VarTemplateDecl *PrevTemplate = Previous.getAsSingle<VarTemplateDecl>();
+
+    if (PrevTemplate) {
+      // Explicitly instantiate a variable template.
+      assert(getLangOpts().CPlusPlus1y &&
+       "Variable templates are only supported in C++1y");
+
+      // If the declarator is a template-id, translate the parser's template
+      // argument list into our AST format.
+      TemplateArgumentListInfo TemplateArgs;
+      if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
+        TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
+        TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
+        TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
+        ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
+                   TemplateId->NumArgs);
+        translateTemplateArguments(TemplateArgsPtr, TemplateArgs);
+      }
+
+      DeclResult Res = CheckVarTemplateId(PrevTemplate, TemplateLoc,
+                                          D.getIdentifierLoc(),
+                 const_cast<const TemplateArgumentListInfo &>(TemplateArgs));
+      if(Res.isInvalid())
+        return true;
+
+      // Ignore access control bits, we don't need them for redeclaration checking.
+      Prev = cast<VarDecl>(Res.get());
+      
+      // Check the new variable specialization against the parsed input.
+      // (Attributes are merged later below.)
+      // FIXME: Model this against function specializations where 
+      // a new function declaration is checked against the specialization 
+      // as candidate for redefinition... (?)
+      if(!Context.hasSameType(Prev->getType(), R)) {
+        Diag(D.getIdentifierLoc(),
+             diag::err_invalid_var_template_spec_type)
+          << 0 << PrevTemplate << R << Prev->getType();
+        Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
+          << 2 << PrevTemplate->getDeclName();
+        return true;
+      }
     }
+    else {
+      if (!Prev || !Prev->isStaticDataMember()) {
+        // We expect to see a data data member here.
+        Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
+          << Name;
+        for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
+             P != PEnd; ++P)
+          Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
+        return true;
+      }
 
       if (!Prev->getInstantiatedFromStaticDataMember()) {
         // FIXME: Check for explicit specialization?
         Diag(D.getIdentifierLoc(),
              diag::err_explicit_instantiation_data_member_not_instantiated)
           << Prev;
         Diag(Prev->getLocation(), diag::note_explicit_instantiation_here);
         // FIXME: Can we provide a note showing where this was declared?
         return true;
+      }
     }
 
     // C++0x [temp.explicit]p2:

     //   name shall be a simple-template-id.
     //
     // C++98 has the same restriction, just worded differently.
-    if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()))
+    if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()) &&
+        (!PrevTemplate ||
+            (D.getName().getKind() != UnqualifiedId::IK_TemplateId &&
+                D.getCXXScopeSpec().isSet())))
       Diag(D.getIdentifierLoc(),
            diag::ext_explicit_instantiation_without_qualified_id)
         << Prev << D.getCXXScopeSpec().getRange();

     CheckExplicitInstantiationScope(*this, Prev, D.getIdentifierLoc(), true);
 
     // Verify that it is okay to explicitly instantiate here.
-    MemberSpecializationInfo *MSInfo = Prev->getMemberSpecializationInfo();
-    assert(MSInfo && "Missing static data member specialization info?");
     bool HasNoEffect = false;
-    if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
-                                        MSInfo->getTemplateSpecializationKind(),
-                                              MSInfo->getPointOfInstantiation(),
-                                               HasNoEffect))
-      return true;
+    if(MemberSpecializationInfo *MSInfo = Prev->getMemberSpecializationInfo()) {
+      assert(MSInfo && "Missing static data member specialization info?");
+      if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
+                                          MSInfo->getTemplateSpecializationKind(),
+                                                MSInfo->getPointOfInstantiation(),
+                                                 HasNoEffect))
+        return true;
+    } else if(PrevTemplate) {
+      if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
+                                          Prev->getTemplateSpecializationKind(),
+          cast<VarTemplateSpecializationDecl>(Prev)->getPointOfInstantiation(),
+                                                 HasNoEffect))
+        return true;
+    }
     if (HasNoEffect)
       return (Decl*) 0;
 
     // Instantiate static data member.
     Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
-    if (TSK == TSK_ExplicitInstantiationDefinition)
-      InstantiateStaticDataMemberDefinition(D.getIdentifierLoc(), Prev);
+    if (PrevTemplate) {
+      // Merge attributes.
+      if (AttributeList *Attr = D.getDeclSpec().getAttributes().getList())
+        ProcessDeclAttributeList(S, Prev, Attr);
+    }
+    if (TSK == TSK_ExplicitInstantiationDefinition) {
+      if (PrevTemplate)
+        InstantiateVariableDefinition(D.getIdentifierLoc(), Prev);
+      else
+        InstantiateStaticDataMemberDefinition(D.getIdentifierLoc(), Prev);
+    }
 
     // FIXME: Create an ExplicitInstantiation node?
     return (Decl*) 0;

lib/Sema/SemaTemplateDeduction.cpp

 
       ++ArgIdx;
     }
     
     // Build argument packs for each of the parameter packs expanded by this
     // pack expansion.
     if (Sema::TemplateDeductionResult Result

   // the template argument explicitly.
   TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType,
                                                              Info.getLocation());
   
   // Check the template argument, converting it as necessary.
   return S.CheckTemplateArgument(Param, ArgLoc,
                                  Template,

                                            Deduced, Info);
 }
 
+/// Complete template argument deduction for a variable template partial
+/// specialization.
+/// TODO: Unify with ClassTemplatePartialSpecializationDecl version.
+static Sema::TemplateDeductionResult
+FinishTemplateArgumentDeduction(Sema &S,
+                                VarTemplatePartialSpecializationDecl *Partial,
+                                const TemplateArgumentList &TemplateArgs,
+                      SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+                                TemplateDeductionInfo &Info) {
+  // Unevaluated SFINAE context.
+  EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
+  Sema::SFINAETrap Trap(S);
+
+  // C++ [temp.deduct.type]p2:
+  //   [...] or if any template argument remains neither deduced nor
+  //   explicitly specified, template argument deduction fails.
+  SmallVector<TemplateArgument, 4> Builder;
+  TemplateParameterList *PartialParams = Partial->getTemplateParameters();
+  for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) {
+    NamedDecl *Param = PartialParams->getParam(I);
+    if (Deduced[I].isNull()) {
+      Info.Param = makeTemplateParameter(Param);
+      return Sema::TDK_Incomplete;
+    }
+
+    // We have deduced this argument, so it still needs to be
+    // checked and converted.
+
+    // First, for a non-type template parameter type that is
+    // initialized by a declaration, we need the type of the
+    // corresponding non-type template parameter.
+    QualType NTTPType;
+    if (NonTypeTemplateParmDecl *NTTP
+                                  = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
+      NTTPType = NTTP->getType();
+      if (NTTPType->isDependentType()) {
+        TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
+                                          Builder.data(), Builder.size());
+        NTTPType = S.SubstType(NTTPType,
+                               MultiLevelTemplateArgumentList(TemplateArgs),
+                               NTTP->getLocation(),
+                               NTTP->getDeclName());
+        if (NTTPType.isNull()) {
+          Info.Param = makeTemplateParameter(Param);
+          // FIXME: These template arguments are temporary. Free them!
+          Info.reset(TemplateArgumentList::CreateCopy(S.Context,
+                                                      Builder.data(),
+                                                      Builder.size()));
+          return Sema::TDK_SubstitutionFailure;
+        }
+      }
+    }
+
+    if (ConvertDeducedTemplateArgument(S, Param, Deduced[I],
+                                       Partial, NTTPType, 0, Info, false,
+                                       Builder)) {
+      Info.Param = makeTemplateParameter(Param);
+      // FIXME: These template arguments are temporary. Free them!
+      Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
+                                                  Builder.size()));
+      return Sema::TDK_SubstitutionFailure;
+    }
+  }
+
+  // Form the template argument list from the deduced template arguments.
+  TemplateArgumentList *DeducedArgumentList
+    = TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
+                                       Builder.size());
+
+  Info.reset(DeducedArgumentList);
+
+  // Substitute the deduced template arguments into the template
+  // arguments of the class template partial specialization, and
+  // verify that the instantiated template arguments are both valid
+  // and are equivalent to the template arguments originally provided
+  // to the class template.
+  LocalInstantiationScope InstScope(S);
+  VarTemplateDecl *VarTemplate = Partial->getSpecializedTemplate();
+  const TemplateArgumentLoc *PartialTemplateArgs
+    = Partial->getTemplateArgsAsWritten();
+
+  // Note that we don't provide the langle and rangle locations.
+  TemplateArgumentListInfo InstArgs;
+
+  if (S.Subst(PartialTemplateArgs,
+              Partial->getNumTemplateArgsAsWritten(),
+              InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) {
+    unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx;
+    if (ParamIdx >= Partial->getTemplateParameters()->size())
+      ParamIdx = Partial->getTemplateParameters()->size() - 1;
+
+    Decl *Param
+      = const_cast<NamedDecl *>(
+                          Partial->getTemplateParameters()->getParam(ParamIdx));
+    Info.Param = makeTemplateParameter(Param);
+    Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument();
+    return Sema::TDK_SubstitutionFailure;
+  }
+  SmallVector<TemplateArgument, 4> ConvertedInstArgs;
+  if (S.CheckTemplateArgumentList(VarTemplate, Partial->getLocation(),
+                                  InstArgs, false, ConvertedInstArgs))
+    return Sema::TDK_SubstitutionFailure;
+
+  TemplateParameterList *TemplateParams
+    = VarTemplate->getTemplateParameters();
+  for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
+    TemplateArgument InstArg = ConvertedInstArgs.data()[I];
+    if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) {
+      Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
+      Info.FirstArg = TemplateArgs[I];
+      Info.SecondArg = InstArg;
+      return Sema::TDK_NonDeducedMismatch;
+    }
+  }
+
+  if (Trap.hasErrorOccurred())
+    return Sema::TDK_SubstitutionFailure;
+
+  return Sema::TDK_Success;
+}
+
+
+/// \brief Perform template argument deduction to determine whether
+/// the given template arguments match the given class template
+/// partial specialization per C++ [temp.class.spec.match].
+/// TODO: Unify with ClassTemplatePartialSpecializationDecl version.
+Sema::TemplateDeductionResult
+Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
+                              const TemplateArgumentList &TemplateArgs,
+                              TemplateDeductionInfo &Info) {
+  if (Partial->isInvalidDecl())
+    return TDK_Invalid;
+
+  // C++ [temp.class.spec.match]p2:
+  //   A partial specialization matches a given actual template
+  //   argument list if the template arguments of the partial
+  //   specialization can be deduced from the actual template argument
+  //   list (14.8.2).
+
+  // Unevaluated SFINAE context.
+  EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
+  SFINAETrap Trap(*this);
+
+  SmallVector<DeducedTemplateArgument, 4> Deduced;
+  Deduced.resize(Partial->getTemplateParameters()->size());
+  if (TemplateDeductionResult Result
+        = ::DeduceTemplateArguments(*this,
+                                    Partial->getTemplateParameters(),
+                                    Partial->getTemplateArgs(),
+                                    TemplateArgs, Info, Deduced))
+    return Result;
+  
+  SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
+  InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial,
+                             DeducedArgs, Info);
+  if (Inst)
+    return TDK_InstantiationDepth;
+
+  if (Trap.hasErrorOccurred())
+    return Sema::TDK_SubstitutionFailure;
+
+  return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs,
+                                           Deduced, Info);
+}
+
 /// \brief Determine whether the given type T is a simple-template-id type.
 static bool isSimpleTemplateIdType(QualType T) {
   if (const TemplateSpecializationType *Spec

   return Better1? PS1 : PS2;
 }
 
+/// \brief Returns the more specialized class template partial specialization
+/// according to the rules of partial ordering of class template partial
+/// specializations (C++ [temp.class.order]).
+///
+/// \param PS1 the first class template partial specialization
+///
+/// \param PS2 the second class template partial specialization
+///
+/// \returns the more specialized class template partial specialization. If
+/// neither partial specialization is more specialized, returns NULL.
+/// TODO: Unify with ClassTemplatePartialSpecializationDecl version.
+VarTemplatePartialSpecializationDecl *
+Sema::getMoreSpecializedPartialSpecialization(
+                                  VarTemplatePartialSpecializationDecl *PS1,
+                                  VarTemplatePartialSpecializationDecl *PS2,
+                                              SourceLocation Loc) {
+
+  SmallVector<DeducedTemplateArgument, 4> Deduced;
+  TemplateDeductionInfo Info(Loc);
+
+  //QualType PT1 = PS1->getInjectedSpecializationType();
+  //QualType PT2 = PS2->getInjectedSpecializationType();
+  assert(PS1->getSpecializedTemplate() == PS1->getSpecializedTemplate() &&
+          "the partial specializations being compared should specialize"
+          " the same template.");
+  TemplateName Name(PS1->getSpecializedTemplate());
+  TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
+  QualType PT1
+    = Context.getTemplateSpecializationType(CanonTemplate, 
+                                            PS1->getTemplateArgs().data(),
+                                            PS1->getTemplateArgs().size());
+  QualType PT2
+    = Context.getTemplateSpecializationType(CanonTemplate, 
+                                            PS2->getTemplateArgs().data(),
+                                            PS2->getTemplateArgs().size());
+
+  // Determine whether PS1 is at least as specialized as PS2
+  Deduced.resize(PS2->getTemplateParameters()->size());
+  bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this,
+                                            PS2->getTemplateParameters(),
+                                            PT2, PT1, Info, Deduced, TDF_None,
+                                            /*PartialOrdering=*/true,
+                                            /*RefParamComparisons=*/0);
+  if (Better1) {
+    SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
+    InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2,
+                               DeducedArgs, Info);
+    Better1 = !::FinishTemplateArgumentDeduction(*this, PS2,
+                                                 PS1->getTemplateArgs(),
+                                                 Deduced, Info);
+  }
+
+  // Determine whether PS2 is at least as specialized as PS1
+  Deduced.clear();
+  Deduced.resize(PS1->getTemplateParameters()->size());
+  bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this,
+                                            PS1->getTemplateParameters(),
+                                            PT1, PT2, Info, Deduced, TDF_None,
+                                            /*PartialOrdering=*/true,
+                                            /*RefParamComparisons=*/0);
+  if (Better2) {
+    SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
+    InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1,
+                               DeducedArgs, Info);
+    Better2 = !::FinishTemplateArgumentDeduction(*this, PS1,
+                                                 PS2->getTemplateArgs(),
+                                                 Deduced, Info);
+  }
+
+  if (Better1 == Better2)
+    return 0;
+
+  return Better1? PS1 : PS2;
+}
+
 static void
 MarkUsedTemplateParameters(ASTContext &Ctx,
                            const TemplateArgument &TemplateArg,

lib/Sema/SemaTemplateInstantiate.cpp

                                    const FunctionDecl *Pattern) {
   // Accumulate the set of template argument lists in this structure.
   MultiLevelTemplateArgumentList Result;
   
   if (Innermost)
     Result.addOuterTemplateArguments(Innermost);
   

   if (!Ctx) {
     Ctx = D->getDeclContext();
     
+    // Add template arguments from a variable template instantiation.
+    if (VarTemplateSpecializationDecl *Spec
+        = dyn_cast<VarTemplateSpecializationDecl>(D)) {
+     // We're done when we hit an explicit specialization.
+     if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
+         !isa<VarTemplatePartialSpecializationDecl>(Spec))
+       return Result;
+
+     Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
+     
+     // If this variable template specialization was instantiated from a 
+     // specialized member that is a variable template, we're done.
+     assert(Spec->getSpecializedTemplate() && "No variable template?");
+     if (Spec->getSpecializedTemplate()->isMemberSpecialization())
+       return Result;
+   }
+    
     // If we have a template template parameter with translation unit context,
     // then we're performing substitution into a default template argument of
     // this template template parameter before we've constructed the template

 
 Sema::InstantiatingTemplate::
 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
+                      VarTemplatePartialSpecializationDecl *PartialSpec,
+                      ArrayRef<TemplateArgument> TemplateArgs,
+                      sema::TemplateDeductionInfo &DeductionInfo,
+                      SourceRange InstantiationRange)
+  : SemaRef(SemaRef),
+    SavedInNonInstantiationSFINAEContext(
+                                     SemaRef.InNonInstantiationSFINAEContext)
+{
+  Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
+  if (!Invalid) {
+    ActiveTemplateInstantiation Inst;
+    Inst.Kind = ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution;
+    Inst.PointOfInstantiation = PointOfInstantiation;
+    Inst.Entity = PartialSpec;
+    Inst.TemplateArgs = TemplateArgs.data();
+    Inst.NumTemplateArgs = TemplateArgs.size();
+    Inst.DeductionInfo = &DeductionInfo;
+    Inst.InstantiationRange = InstantiationRange;
+    SemaRef.InNonInstantiationSFINAEContext = false;
+    SemaRef.ActiveTemplateInstantiations.push_back(Inst);
+  }
+}
+
+Sema::InstantiatingTemplate::
+InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
                       ParmVarDecl *Param,
                       ArrayRef<TemplateArgument> TemplateArgs,
                       SourceRange InstantiationRange)

     // Fall through to find the instantiated declaration for this template
     // template parameter.
   }
   
   return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
 }
 

lib/Sema/SemaTemplateInstantiateDecl.cpp

   return Inst;
 }
 
+// FIXME: Revise for static member templates.
 Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) {
+  
+  // In C++11: Check whether there is already a variable template
+  // specialization for this declaration.
+  TemplateArgumentListInfo VarTemplateArgsInfo;
+  SmallVector<TemplateArgument, 4> Converted;
+  VarTemplateDecl *VarTemplate = 0;
+  if (isa<VarTemplateSpecializationDecl>(D)) {
+    assert(SemaRef.getLangOpts().CPlusPlus1y &&
+           "Variable templates are only supported in C++1y");
+    VarTemplateSpecializationDecl *VarSpec
+      = cast<VarTemplateSpecializationDecl>(D);
+    VarTemplate = VarSpec->getSpecializedTemplate();
+    assert(VarTemplate &&
+     "A template specialization without specialized template?");
+    
+    // Substitute the current template arguments.
+    const TemplateArgumentListInfo &TemplateArgsInfo
+      = VarSpec->getTemplateArgsInfo();
+    VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo.getLAngleLoc());
+    VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo.getRAngleLoc());
+    
+    if (SemaRef.Subst(TemplateArgsInfo.getArgumentArray(),
+                      TemplateArgsInfo.size(),
+                      VarTemplateArgsInfo, TemplateArgs))
+      return 0;
+    
+    // Check that the template argument list is well-formed for this
+    // template.
+    bool ExpansionIntoFixedList = false;
+    if (SemaRef.CheckTemplateArgumentList(VarTemplate, VarTemplate->getLocStart(), 
+                                          VarTemplateArgsInfo,
+                                          false, Converted, &ExpansionIntoFixedList))
+      return 0;
+
+    // Find the variable template specialization declaration that
+    // corresponds to these arguments.
+    void *InsertPos = 0;
+    if (VarTemplateSpecializationDecl *SpecVar
+        = VarTemplate->findSpecialization(Converted.data(), Converted.size(),
+                                          InsertPos))
+      // If we already have a variable template specialization, return it.
+      return SpecVar;
+  }
+  
   // If this is the variable for an anonymous struct or union,
   // instantiate the anonymous struct/union type first.
   if (const RecordType *RecordTy = D->getType()->getAs<RecordType>())

       << D->isStaticDataMember() << DI->getType();
     return 0;
   }
   
+  VarDecl *PrevDecl = 0;
+  if (SemaRef.getLangOpts().CPlusPlus1y && D->getPreviousDecl()) {
+    if (D->getDescribedVarTemplate()) {
+      // FIXME: This is repetitive with VisitVarTemplateDecl.
+      DeclContext::lookup_result Found = Owner->lookup(D->getDeclName());
+      if (!Found.empty()) {
+        if (VarTemplateDecl *PrevVarTemplate 
+              = dyn_cast<VarTemplateDecl>(Found.front()))
+          PrevDecl = PrevVarTemplate->getTemplatedDecl();
+      }
+    }/* FIXME: ??? Make sure this doesn't cause infinite recursion.
+    else {
+      NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
+                                                     D->getPreviousDecl(),
+                                                     TemplateArgs);
+      if (!Prev) return 0;
+      PrevDecl = cast<VarDecl>(Prev);
+    }*/
+  }
+  
   // Build the instantiated declaration
-  VarDecl *Var = VarDecl::Create(SemaRef.Context, Owner,
+  VarDecl *Var;
+  if (isa<VarTemplateSpecializationDecl>(D)) {
+    assert(VarTemplate && "Something wrong?");
+    Var = VarTemplateSpecializationDecl::Create(SemaRef.Context,
+                                                Owner,
+                                                D->getInnerLocStart(),
+                                                D->getLocation(),
+                                                VarTemplate,
+                                                DI->getType(), DI,
+                                                D->getStorageClass(), 
+                                                Converted.data(),
+                                                Converted.size(), 0);
+    cast<VarTemplateSpecializationDecl>(Var)->setTemplateArgsInfo(
+                                                  VarTemplateArgsInfo);
+  } else
+    Var = VarDecl::Create(SemaRef.Context, Owner,
                                  D->getInnerLocStart(),
                                  D->getLocation(), D->getIdentifier(),
                                  DI->getType(), DI,
-                                 D->getStorageClass());
+                                 D->getStorageClass(), 
+                                 PrevDecl);
   Var->setTSCSpec(D->getTSCSpec());
   Var->setInitStyle(D->getInitStyle());
   Var->setCXXForRangeDecl(D->isCXXForRangeDecl());

   if (Var->isStaticDataMember())
     SemaRef.Context.setInstantiatedFromStaticDataMember(Var, D,
                                                      TSK_ImplicitInstantiation);
   
-  if (Var->getAnyInitializer()) {
-    // We already have an initializer in the class.
-  } else if (D->getInit()) {
-    if (Var->isStaticDataMember() && !D->isOutOfLine())
-      SemaRef.PushExpressionEvaluationContext(Sema::ConstantEvaluated, D);
-    else
-      SemaRef.PushExpressionEvaluationContext(Sema::PotentiallyEvaluated, D);
-
-    // Instantiate the initializer.
-    ExprResult Init = SemaRef.SubstInitializer(D->getInit(), TemplateArgs,
-                                        D->getInitStyle() == VarDecl::CallInit);
-    if (!Init.isInvalid()) {
-      bool TypeMayContainAuto = true;
-      if (Init.get()) {
-        bool DirectInit = D->isDirectInit();
-        SemaRef.AddInitializerToDecl(Var, Init.take(), DirectInit,
-                                     TypeMayContainAuto);
-      } else
-        SemaRef.ActOnUninitializedDecl(Var, TypeMayContainAuto);
-    } else {
-      // FIXME: Not too happy about invalidating the declaration
-      // because of a bogus initializer.
-      Var->setInvalidDecl();
-    }
-
-    SemaRef.PopExpressionEvaluationContext();
-  } else if ((!Var->isStaticDataMember() || Var->isOutOfLine()) &&
-             !Var->isCXXForRangeDecl())
-    SemaRef.ActOnUninitializedDecl(Var, false);
-
+  if (isa<VarTemplateSpecializationDecl>(D)) {
+    // Do not instantiate the variable just yet. 
+    // Instantiation is handled by DoMarkVarDeclReferenced().
+  }
+  else
+    SemaRef.InstantiateVariableInitializer(Var, D, TemplateArgs);
+    
   // Diagnose unused local variables with dependent types, where the diagnostic
   // will have been deferred.
   if (!Var->isInvalidDecl() && Owner->isFunctionOrMethod() && !Var->isUsed() &&
       D->getType()->isDependentType())
     SemaRef.DiagnoseUnusedDecl(Var);
   
   return Var;
 }
 

   return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D);
 }
 
+Decl *TemplateDeclInstantiator::VisitVarTemplateDecl(VarTemplateDecl *D) {
+  // FIXME: This should only be used for static data member templates.
+  
+  assert(SemaRef.getLangOpts().CPlusPlus1y && 
+          "Variable template are only supported in C++1y");
+
+  // Create a local instantiation scope for this variable template, which
+  // will contain the instantiations of the template parameters.
+  LocalInstantiationScope Scope(SemaRef);
+  TemplateParameterList *TempParams = D->getTemplateParameters();
+  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
+  if (!InstParams)
+    return NULL;
+
+  VarDecl *Pattern = D->getTemplatedDecl();
+  VarTemplateDecl *PrevVarTemplate = 0;
+  
+  if (Pattern->getPreviousDecl()) {
+    // FIXME: This is repetitive with VisitVarDecl()
+    DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
+    if (!Found.empty()) 
+      PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
+  }
+  
+  VarDecl *VarInst = cast_or_null<VarDecl>(VisitVarDecl(Pattern));
+
+  DeclContext *DC = Owner;
+  /*
+  // If this is the variable for an anonymous struct or union,
+  // instantiate the anonymous struct/union type first.
+  if (const RecordType *RecordTy = Pattern->getType()->getAs<RecordType>())
+    if (RecordTy->getDecl()->isAnonymousStructOrUnion())
+      if (!VisitCXXRecordDecl(cast<CXXRecordDecl>(RecordTy->getDecl())))
+        return 0;
+
+  if (Pattern->getPreviousDecl()) {
+    DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
+    if (!Found.empty()) {
+      PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
+      if (PrevVarTemplate)
+        PrevDecl = PrevVarTemplate->getTemplatedDecl();
+    }
+  }
+
+  // Do substitution on the type of the declaration
+  TypeSourceInfo *DI = SemaRef.SubstType(Pattern->getTypeSourceInfo(),
+                                         TemplateArgs,
+                                         Pattern->getTypeSpecStartLoc(),
+                                         Pattern->getDeclName());
+  if (!DI)
+    return 0;
+
+  if (DI->getType()->isFunctionType()) {
+    SemaRef.Diag(Pattern->getLocation(), diag::err_variable_instantiates_to_function)
+      << Pattern->isStaticDataMember() << DI->getType();
+    return 0;
+  }
+  
+  // This isn't a friend, thus it's a static member template. Therefore,
+  // we just want to build the instantiation in the specialization.
+  assert(Pattern->isStaticDataMember() && 
+          "Should this be restricted to static data members?");
+  DeclContext *DC = Owner;
+  VarDecl *VarInst
+    = VarDecl::Create(SemaRef.Context, DC,
+                      Pattern->getInnerLocStart(), Pattern->getLocation(),
+                      Pattern->getIdentifier(), DI->getType(), DI,
+                      Pattern->getStorageClass(), PrevDecl);
+  VarInst->setTSCSpec(Pattern->getTSCSpec());
+  VarInst->setInitStyle(Pattern->getInitStyle());
+  VarInst->setCXXForRangeDecl(Pattern->isCXXForRangeDecl());
+  VarInst->setConstexpr(Pattern->isConstexpr());
+  
+  // Substitute the nested name specifier, if any.
+  if (SubstQualifier(Pattern, VarInst))
+    return 0;
+  */
+
+  // Instantiate the qualifier.  
+  NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
+  if (QualifierLoc) {
+    QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
+                                                       TemplateArgs);
+    if (!QualifierLoc)
+      return 0;
+  }
+
+  if (QualifierLoc)
+    VarInst->setQualifierInfo(QualifierLoc);
+
+  VarTemplateDecl *Inst
+    = VarTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
+                                D->getIdentifier(), InstParams, VarInst,
+                                PrevVarTemplate);
+  VarInst->setDescribedVarTemplate(Inst);
+
+  Inst->setAccess(D->getAccess());
+  if (!PrevVarTemplate)
+    Inst->setInstantiatedFromMemberTemplate(D);
+
+  if (D->isOutOfLine()) {
+    Inst->setLexicalDeclContext(D->getLexicalDeclContext());
+    VarInst->setLexicalDeclContext(D->getLexicalDeclContext());
+  }
+
+  Owner->addDecl(Inst);
+
+  if (!PrevVarTemplate) {
+    // Queue up any out-of-line partial specializations of this member
+    // variable template; the client will force their instantiation once
+    // the enclosing class has been instantiated.
+    SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
+    D->getPartialSpecializations(PartialSpecs);
+    for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
+      if (PartialSpecs[I]->isOutOfLine())
+        OutOfLineVarPartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
+  }
+
+  return Inst;
+}
+
+Decl *
+TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
+                                   VarTemplatePartialSpecializationDecl *D) {
+  // FIXME: This should only be used for static data member templates (?)
+  VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
+
+  // Lookup the already-instantiated declaration in the instantiation
+  // of the variable template and return that.
+  DeclContext::lookup_result Found
+    = Owner->lookup(VarTemplate->getDeclName());
+  if (Found.empty())
+    return 0;
+
+  VarTemplateDecl *InstVarTemplate
+    = dyn_cast<VarTemplateDecl>(Found.front());
+  if (!InstVarTemplate)
+    return 0;
+
+  if (VarTemplatePartialSpecializationDecl *Result
+        = InstVarTemplate->findPartialSpecInstantiatedFromMember(D))
+    return Result;
+
+  return InstantiateVarTemplatePartialSpecialization(InstVarTemplate, D);
+}
+
+
 Decl *
 TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
   // Create a local instantiation scope for this function template, which

                    "inside templates");
 }
 
+Decl *
+TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
+    VarTemplateSpecializationDecl *D) {
+  return VisitVarDecl(D);
+}
+
 Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
   llvm_unreachable("@defs is not supported in Objective-C++");
 }

   return InstPartialSpec;
 }
 
+
+/// \brief Instantiate the declaration of a variable template partial
+/// specialization.
+///
+/// \param VarTemplate the (instantiated) variable template that is partially
+/// specialized by the instantiation of \p PartialSpec.
+///
+/// \param PartialSpec the (uninstantiated) variable template partial
+/// specialization that we are instantiating.
+///
+/// \returns The instantiated partial specialization, if successful; otherwise,
+/// NULL to indicate an error.
+VarTemplatePartialSpecializationDecl *
+TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(
+                                            VarTemplateDecl *VarTemplate,
+                          VarTemplatePartialSpecializationDecl *PartialSpec) {
+  // Create a local instantiation scope for this variable template partial
+  // specialization, which will contain the instantiations of the template
+  // parameters.
+  LocalInstantiationScope Scope(SemaRef);
+
+  // Substitute into the template parameters of the variable template partial
+  // specialization.
+  TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
+  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
+  if (!InstParams)
+    return 0;
+
+  // Substitute into the template arguments of the variable template partial
+  // specialization.
+  TemplateArgumentListInfo InstTemplateArgs; // no angle locations
+  if (SemaRef.Subst(PartialSpec->getTemplateArgsAsWritten(),
+                    PartialSpec->getNumTemplateArgsAsWritten(),
+                    InstTemplateArgs, TemplateArgs))
+    return 0;
+
+  // Check that the template argument list is well-formed for this
+  // class template.
+  SmallVector<TemplateArgument, 4> Converted;
+  if (SemaRef.CheckTemplateArgumentList(VarTemplate,
+                                        PartialSpec->getLocation(),
+                                        InstTemplateArgs,
+                                        false,
+                                        Converted))
+    return 0;
+
+  // Figure out where to insert this variable template partial specialization
+  // in the member template's set of variable template partial specializations.
+  void *InsertPos = 0;
+  VarTemplateSpecializationDecl *PrevDecl
+    = VarTemplate->findPartialSpecialization(Converted.data(),
+                                               Converted.size(), InsertPos);
+
+  // Build the canonical type that describes the converted template
+  // arguments of the variable template partial specialization.
+  QualType CanonType
+    = SemaRef.Context.getTemplateSpecializationType(TemplateName(VarTemplate),
+                                                    Converted.data(),
+                                                    Converted.size());
+
+  // Build the fully-sugared type for this variable template
+  // specialization as the user wrote in the specialization
+  // itself. This means that we'll pretty-print the type retrieved
+  // from the specialization's declaration the way that the user
+  // actually wrote the specialization, rather than formatting the
+  // name based on the "canonical" representation used to store the
+  // template arguments in the specialization.
+  TypeSourceInfo *WrittenTy
+    = SemaRef.Context.getTemplateSpecializationTypeInfo(
+                                                    TemplateName(VarTemplate),
+                                                    PartialSpec->getLocation(),
+                                                    InstTemplateArgs,
+                                                    CanonType);
+
+  if (PrevDecl) {
+    // We've already seen a partial specialization with the same template
+    // parameters and template arguments. This can happen, for example, when
+    // substituting the outer template arguments ends up causing two
+    // variable template partial specializations of a member variable template
+    // to have identical forms, e.g.,
+    //
+    //   template<typename T, typename U>
+    //   struct Outer {
+    //     template<typename X, typename Y> pair<X,Y> p;
+    //     template<typename Y> pair<T, Y> p;
+    //     template<typename Y> pair<U, Y> p;
+    //   };
+    //
+    //   Outer<int, int> outer; // error: the partial specializations of Inner
+    //                          // have the same signature.
+    SemaRef.Diag(PartialSpec->getLocation(), diag::err_var_partial_spec_redeclared)
+      << WrittenTy->getType();
+    SemaRef.Diag(PrevDecl->getLocation(), diag::note_var_prev_partial_spec_here);
+      //<< SemaRef.Context.getTypeDeclType(PrevDecl);
+    return 0;
+  }
+
+  // Do substitution on the type of the declaration
+  TypeSourceInfo *DI = SemaRef.SubstType(PartialSpec->getTypeSourceInfo(),
+                                         TemplateArgs,
+                                         PartialSpec->getTypeSpecStartLoc(),
+                                         PartialSpec->getDeclName());
+  if (!DI)
+    return 0;
+
+  if (DI->getType()->isFunctionType()) {
+    SemaRef.Diag(PartialSpec->getLocation(), 
+                  diag::err_variable_instantiates_to_function)
+      << PartialSpec->isStaticDataMember() << DI->getType();
+    return 0;
+  }
+
+  // Create the variable template partial specialization declaration.
+  VarTemplatePartialSpecializationDecl *InstPartialSpec
+    = VarTemplatePartialSpecializationDecl::Create(SemaRef.Context,
+                                                   Owner,
+                                                   PartialSpec->getInnerLocStart(),
+                                                   PartialSpec->getLocation(),
+                                                   InstParams,
+                                                   VarTemplate,
+                                                   DI->getType(), DI,
+                                                   PartialSpec->getStorageClass(),
+                                                   Converted.data(),
+                                                   Converted.size(),
+                                                   InstTemplateArgs,
+                                                   //CanonType,
+                                                   0,
+                             VarTemplate->getNextPartialSpecSequenceNumber());
+
+  // Substitute the nested name specifier, if any.
+  if (SubstQualifier(PartialSpec, InstPartialSpec))
+    return 0;
+
+  InstPartialSpec->setInstantiatedFromMember(PartialSpec);
+  InstPartialSpec->setTypeAsWritten(WrittenTy);
+
+  // Add this partial specialization to the set of class template partial
+  // specializations.
+  VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/0);
+  return InstPartialSpec;
+}
+
 TypeSourceInfo*
 TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
                               SmallVectorImpl<ParmVarDecl *> &Params) {

                             PendingLocalImplicitInstantiations);
 }
 
+// FIXME: How much of variable instantiation should go in here?
+// (cf. VisitVarDecl(), InstantiateVariableDefinition(), and 
+// CheckVarTemplateId())
+void Sema::InstantiateVariableInitializer(VarDecl* Var, 
+                                          VarDecl* OldVar,
+                const MultiLevelTemplateArgumentList &TemplateArgs) {
+  if (Var->getAnyInitializer()) 
+    // We already have an initializer in the class.
+    return;
+  
+  if (OldVar->getInit()) {
+    if (Var->isStaticDataMember() && !OldVar->isOutOfLine())
+      PushExpressionEvaluationContext(Sema::ConstantEvaluated, OldVar);
+    else
+      PushExpressionEvaluationContext(Sema::PotentiallyEvaluated, OldVar);
+
+    // Instantiate the initializer.
+    ExprResult Init = SubstInitializer(OldVar->getInit(), TemplateArgs,
+                                 OldVar->getInitStyle() == VarDecl::CallInit);
+    if (!Init.isInvalid()) {
+      bool TypeMayContainAuto = true;
+      if (Init.get()) {
+        bool DirectInit = OldVar->isDirectInit();
+        AddInitializerToDecl(Var, Init.take(), DirectInit,
+                             TypeMayContainAuto);
+      } else
+        ActOnUninitializedDecl(Var, TypeMayContainAuto);
+    } else {
+      // FIXME: Not too happy about invalidating the declaration
+      // because of a bogus initializer.
+      Var->setInvalidDecl();
+    }
+
+    PopExpressionEvaluationContext();
+  } else if ((!Var->isStaticDataMember() || Var->isOutOfLine()) &&
+             !Var->isCXXForRangeDecl())
+    ActOnUninitializedDecl(Var, false);
+  
+  /*
+  // Diagnose unused local variables with dependent types, where the diagnostic
+  // will have been deferred.
+  if (!Var->isInvalidDecl() && Owner->isFunctionOrMethod() && !Var->isUsed() &&
+      D->getType()->isDependentType())
+    SemaRef.DiagnoseUnusedDecl(Var);
+  */
+}
+
+// FIXME: Merge with InstantiateStaticDataMemberDefinition(), 
+//        for static data memeber templates. (?)
+//        => See InstantiateFunctionDefinition() for inspiration.
+//        => Update PerformPendingInstantiations().
+//        => Perhaps also revise DoMarkVarDeclReferenced().
+void Sema::InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
+                                         VarDecl *Var,
+                                         bool Recursive,
+                                         bool DefinitionRequired) {
+  assert(isa<VarTemplateSpecializationDecl>(Var) && 
+          "Only instantiates variable template specializations.");
+  VarTemplateSpecializationDecl *VarSpec = 
+      cast<VarTemplateSpecializationDecl>(Var);
+  
+  bool InstantiationDependent = false;
+  const TemplateArgumentListInfo &VarTemplateArgs = VarSpec->getTemplateArgsInfo();
+  assert((!TemplateSpecializationType::anyDependentTemplateArguments(
+              VarTemplateArgs, InstantiationDependent)) &&
+         "Only instantiate variable template specializations that are "
+         "not type-dependent");
+  
+  if (Var->isInvalidDecl())
+    return;
+
+  // Never instantiate an explicit specialization except if it is a class scope
+  // explicit specialization.
+  if (Var->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
+      //!Var->getClassScopeSpecializationPattern()
+      !isa<VarTemplatePartialSpecializationDecl>(Var))
+    return;
+
+  // Find the variable initialization that we'll be substituting.
+  assert(VarSpec->getSpecializedTemplate() && 
+         "Specialization without specialized template?");
+  VarDecl *PatternDecl = 0;
+  llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
+  PatternPtr = VarSpec->getSpecializedTemplateOrPartial();
+  if (PatternPtr.is<VarTemplatePartialSpecializationDecl*>())
+    PatternDecl = PatternPtr.get<VarTemplatePartialSpecializationDecl*>();
+  else
+    PatternDecl = (PatternPtr.get<VarTemplateDecl*>())->getTemplatedDecl();
+  assert(PatternDecl && "instantiating a non-template");
+  Expr *Pattern = PatternDecl->getInit();
+
+  if (!Pattern) {
+    if (DefinitionRequired) {
+      VarDecl* Def = Var->getInstantiatedFromStaticDataMember();
+      if (!Def)
+        Diag(PointOfInstantiation,
+             diag::err_explicit_instantiation_undefined_var_template)
+          << PatternDecl;
+      else
+        Diag(PointOfInstantiation,
+             diag::err_explicit_instantiation_undefined_member)
+          << 3 << Var->getDeclName() << Var->getDeclContext();
+
+      if (PatternDecl)
+        Diag(PatternDecl->getLocation(),
+             diag::note_explicit_instantiation_here);
+      Var->setInvalidDecl();
+    } else if (Var->getTemplateSpecializationKind()
+                 == TSK_ExplicitInstantiationDefinition) {
+      PendingInstantiations.push_back(
+        std::make_pair(Var, PointOfInstantiation));
+    }
+    
+   return;
+  }
+
+  // If we already have a definition. Thus, we're done.
+  if (Var->getAnyInitializer())
+    return;
+
+  InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
+  if (Inst)
+    return;
+  
+  // If we're performing recursive template instantiation, create our own
+  // queue of pending implicit instantiations that we will instantiate later,
+  // while we're still within our own instantiation context.
+  SmallVector<VTableUse, 16> SavedVTableUses;
+  std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
+  if (Recursive) {
+    VTableUses.swap(SavedVTableUses);
+    PendingInstantiations.swap(SavedPendingInstantiations);
+  }
+
+  EnterExpressionEvaluationContext EvalContext(*this,
+                                               Sema::PotentiallyEvaluated);
+
+  // Enter the scope of this instantiation. We don't use
+  // PushDeclContext because we don't have a scope.
+  ContextRAII previousContext(*this, Var->getDeclContext());
+  LocalInstantiationScope Scope(*this);
+  
+  InstantiateVariableInitializer(Var, PatternDecl, 
+                                getTemplateInstantiationArgs(Var));
+
+  if(MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo())
+    Var->setTemplateSpecializationKind(MSInfo->getTemplateSpecializationKind(),
+                                       MSInfo->getPointOfInstantiation());
+
+  DeclGroupRef DG(Var);
+  Consumer.HandleTopLevelDecl(DG);
+
+  // This variable may have local implicit instantiations that need to be
+  // instantiated within this scope.
+  PerformPendingInstantiations(/*LocalOnly=*/true);
+  Scope.Exit();
+
+  if (Recursive) {
+    // Define any pending vtables.
+    DefineUsedVTables();
+
+    // Instantiate any pending implicit instantiations found during the
+    // instantiation of this template.
+    PerformPendingInstantiations();
+
+    // Restore the set of pending vtables.
+    assert(VTableUses.empty() &&
+           "VTableUses should be empty before it is discarded.");
+    VTableUses.swap(SavedVTableUses);
+
+    // Restore the set of pending implicit instantiations.
+    assert(PendingInstantiations.empty() &&
+           "PendingInstantiations should be empty before it is discarded.");
+    PendingInstantiations.swap(SavedPendingInstantiations);
+  }
+}
+
+
 /// \brief Instantiate the definition of the given variable from its
 /// template.
 ///

 
   return false;
 }
+/*
+static bool isInstantiationOf(VarTemplateDecl *Pattern,
+                              VarTemplateDecl *Instance) {
+  Pattern = Pattern->getCanonicalDecl();
+
+  do {
+    Instance = Instance->getCanonicalDecl();
+    if (Pattern == Instance) return true;
+    Instance = Instance->getInstantiatedFromMemberTemplate();
+  } while (Instance);
+
+  return false;
+}
+ */
 
 static bool isInstantiationOf(FunctionTemplateDecl *Pattern,
                               FunctionTemplateDecl *Instance) {

     return cast<LabelDecl>(Inst);
   }
 
+  // For variable template specializations, update those 
+  // that are still type-dependent.
+  if(isa<VarTemplateSpecializationDecl>(D)) {
+    VarTemplateSpecializationDecl *VarSpec
+      = cast<VarTemplateSpecializationDecl>(D);
+    bool InstantiationDependent = false;
+    const TemplateArgumentListInfo &VarTemplateArgs = VarSpec->getTemplateArgsInfo();
+    if (TemplateSpecializationType::anyDependentTemplateArguments(
+          VarTemplateArgs, InstantiationDependent)) {
+      D = cast<NamedDecl>(SubstDecl(D, CurContext, TemplateArgs));
+    }
+    return D;
+  }
+  
   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
     if (!Record->isDependentContext())
       return D;

                                     DefinitionRequired);
       continue;
     }
+    
+    // Instantiate variable definitions
+    if (VarTemplateSpecializationDecl *VarSpec 
+          = dyn_cast<VarTemplateSpecializationDecl>(Inst.first)) {
+      assert(getLangOpts().CPlusPlus1y && 
+             "variable templates are only supported in c++1y");
+      PrettyDeclStackTraceEntry CrashInfo(*this, VarSpec, SourceLocation(),
+                                          "instantiating variable definition");
+      bool DefinitionRequired = VarSpec->getTemplateSpecializationKind() ==
+                                TSK_ExplicitInstantiationDefinition;
+      InstantiateVariableDefinition(/*FIXME:*/Inst.second, VarSpec, true,
+                                    DefinitionRequired);
+      continue;
+    }
 
     // Instantiate static data member definitions.
     VarDecl *Var = cast<VarDecl>(Inst.first);

lib/Sema/TreeTransform.h

                                                          E->getDecl()));
   if (!ND)
     return ExprError();
   
   DeclarationNameInfo NameInfo = E->getNameInfo();
   if (NameInfo.getName()) {
     NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
     if (!NameInfo.getName())
       return ExprError();
   }
   
   if (!getDerived().AlwaysRebuild() &&
       QualifierLoc == E->getQualifierLoc() &&
       ND == E->getDecl() &&
       NameInfo.getName() == E->getDecl()->getDeclName() &&
       !E->hasExplicitTemplateArgs()) {
     
     // Mark it referenced in the new context regardless.
     // FIXME: this is a bit instantiation-specific.
     SemaRef.MarkDeclRefReferenced(E);
 
     return SemaRef.Owned(E);
   }
   
   TemplateArgumentListInfo TransArgs, *TemplateArgs = 0;
   if (E->hasExplicitTemplateArgs()) {
     TemplateArgs = &TransArgs;

lib/Serialization/ASTCommon.cpp

   case Decl::CXXRecord:
   case Decl::ClassTemplateSpecialization:
   case Decl::ClassTemplatePartialSpecialization:
+  case Decl::VarTemplateSpecialization:
+  case Decl::VarTemplatePartialSpecialization:
   case Decl::Function:
   case Decl::CXXMethod:
   case Decl::CXXConstructor:

   case Decl::Var:
   case Decl::FunctionTemplate:
   case Decl::ClassTemplate:
+  case Decl::VarTemplate:
   case Decl::TypeAliasTemplate:
   case Decl::ObjCProtocol:
   case Decl::ObjCInterface:

lib/Serialization/ASTReaderDecl.cpp

     void VisitTemplateDecl(TemplateDecl *D);
     RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
     void VisitClassTemplateDecl(ClassTemplateDecl *D);
+    void VisitVarTemplateDecl(VarTemplateDecl *D);
     void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
     void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
     void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);

   }
 }
 
+void ASTDeclReader::VisitVarTemplateDecl(VarTemplateDecl *D) {
+  RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
+
+  if (ThisDeclID == Redecl.getFirstID()) {
+    // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
+    // the specializations.
+    SmallVector<serialization::DeclID, 2> SpecIDs;
+    SpecIDs.push_back(0);
+    
+    // Specializations.
+    unsigned Size = Record[Idx++];
+    SpecIDs[0] += Size;
+    for (unsigned I = 0; I != Size; ++I)
+      SpecIDs.push_back(ReadDeclID(Record, Idx));
+
+    // Partial specializations.
+    Size = Record[Idx++];
+    SpecIDs[0] += Size;
+    for (unsigned I = 0; I != Size; ++I)
+      SpecIDs.push_back(ReadDeclID(Record, Idx));
+
+    VarTemplateDecl::Common *CommonPtr = D->getCommonPtr();
+    if (SpecIDs[0]) {
+      typedef serialization::DeclID DeclID;
+      
+      // FIXME: Append specializations!
+      CommonPtr->LazySpecializations
+        = new (Reader.getContext()) DeclID [SpecIDs.size()];
+      memcpy(CommonPtr->LazySpecializations, SpecIDs.data(), 
+             SpecIDs.size() * sizeof(DeclID));
+    }
+  }
+}
+
 ASTDeclReader::RedeclarableResult
 ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
     ClassTemplateSpecializationDecl *D) {

   case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
     D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
     break;
+  case DECL_VAR_TEMPLATE:
+    D = VarTemplateDecl::CreateDeserialized(Context, ID);
+    break;
+  case DECL_VAR_TEMPLATE_SPECIALIZATION:
+    D = VarTemplateSpecializationDecl::CreateDeserialized(Context, ID);
+    break;
+  case DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION:
+    D = VarTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
+    break;
   case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
     D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
     break;

lib/Serialization/ASTWriter.cpp

   RECORD(DECL_CLASS_TEMPLATE);
   RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION);
   RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION);
+  RECORD(DECL_VAR_TEMPLATE);
+  RECORD(DECL_VAR_TEMPLATE_SPECIALIZATION);
+  RECORD(DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION);
   RECORD(DECL_FUNCTION_TEMPLATE);
   RECORD(DECL_TEMPLATE_TYPE_PARM);
   RECORD(DECL_NON_TYPE_TEMPLATE_PARM);

   Record.push_back(reinterpret_cast<uint64_t>(D));
 }
 
+void ASTWriter::AddedCXXTemplateSpecialization(const VarTemplateDecl *TD,
+                                     const VarTemplateSpecializationDecl *D) {
+  // The specializations set is kept in the canonical template.
+  assert(!WritingAST && "Already writing the AST!");
+  TD = TD->getCanonicalDecl();
+  if (!(!D->isFromASTFile() && TD->isFromASTFile()))
+    return; // Not a source specialization added to a template from PCH.
+
+  UpdateRecord &Record = DeclUpdates[TD];
+  Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION);
+  Record.push_back(reinterpret_cast<uint64_t>(D));
+}
+
 void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
                                                const FunctionDecl *D) {
   // The specializations set is kept in the canonical template.

lib/Serialization/ASTWriterDecl.cpp

                                             ClassTemplateSpecializationDecl *D);
     void VisitClassTemplatePartialSpecializationDecl(
                                      ClassTemplatePartialSpecializationDecl *D);
+    void VisitVarTemplateSpecializationDecl(
+                                            VarTemplateSpecializationDecl *D);
+    void VisitVarTemplatePartialSpecializationDecl(
+                                     VarTemplatePartialSpecializationDecl *D);
     void VisitClassScopeFunctionSpecializationDecl(
                                        ClassScopeFunctionSpecializationDecl *D);
     void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);

     void VisitTemplateDecl(TemplateDecl *D);
     void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
     void VisitClassTemplateDecl(ClassTemplateDecl *D);
+    void VisitVarTemplateDecl(VarTemplateDecl *D);
     void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
     void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
     void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);

   Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
 }
 
+void ASTDeclWriter::VisitVarTemplateDecl(VarTemplateDecl *D) {
+  VisitRedeclarableTemplateDecl(D);
+
+  if (D->isFirstDeclaration()) {
+    typedef llvm::FoldingSetVector<VarTemplateSpecializationDecl> CTSDSetTy;
+    CTSDSetTy &CTSDSet = D->getSpecializations();
+    Record.push_back(CTSDSet.size());
+    for (CTSDSetTy::iterator I=CTSDSet.begin(), E = CTSDSet.end(); I!=E; ++I) {
+      assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
+      Writer.AddDeclRef(&*I, Record);
+    }
+
+    typedef llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl>
+      CTPSDSetTy;
+    CTPSDSetTy &CTPSDSet = D->getPartialSpecializations();
+    Record.push_back(CTPSDSet.size());
+    for (CTPSDSetTy::iterator I=CTPSDSet.begin(), E=CTPSDSet.end(); I!=E; ++I) {
+      assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
+      Writer.AddDeclRef(&*I, Record); 
+    }
+
+   // Writer.AddTypeRef(D->getCommonPtr()->InjectedClassNameType, Record);
+  }
+  Code = serialization::DECL_VAR_TEMPLATE;
+}
+
+void ASTDeclWriter::VisitVarTemplateSpecializationDecl(
+                                           VarTemplateSpecializationDecl *D) {
+  VisitVarDecl(D);
+
+  llvm::PointerUnion<VarTemplateDecl *,
+                     VarTemplatePartialSpecializationDecl *> InstFrom
+    = D->getSpecializedTemplateOrPartial();
+  if (Decl *InstFromD = InstFrom.dyn_cast<VarTemplateDecl *>()) {
+    Writer.AddDeclRef(InstFromD, Record);
+  } else {
+    Writer.AddDeclRef(InstFrom.get<VarTemplatePartialSpecializationDecl *>(),
+                      Record);
+    Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record);
+  }
+
+  // Explicit info.
+  Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record);
+  if (D->getTypeAsWritten()) {
+    Writer.AddSourceLocation(D->getExternLoc(), Record);
+    Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record);
+  }
+
+  Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record);
+  Writer.AddSourceLocation(D->getPointOfInstantiation(), Record);
+  Record.push_back(D->getSpecializationKind());
+  Record.push_back(D->isCanonicalDecl());
+
+  if (D->isCanonicalDecl()) {
+    // When reading, we'll add it to the folding set of the following template. 
+    Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record);
+  }
+
+  Code = serialization::DECL_VAR_TEMPLATE_SPECIALIZATION;
+}
+
+void ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl(
+                                    VarTemplatePartialSpecializationDecl *D) {
+  VisitVarTemplateSpecializationDecl(D);
+
+  Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
+
+  Record.push_back(D->getNumTemplateArgsAsWritten());
+  for (int i = 0, e = D->getNumTemplateArgsAsWritten(); i != e; ++i)
+    Writer.AddTemplateArgumentLoc(D->getTemplateArgsAsWritten()[i], Record);
+
+  Record.push_back(D->getSequenceNumber());
+
+  // These are read/set from/to the first declaration.
+  if (D->getPreviousDecl() == 0) {
+    Writer.AddDeclRef(D->getInstantiatedFromMember(), Record);
+    Record.push_back(D->isMemberSpecialization());
+  }
+
+  Code = serialization::DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION;
+}
+
 void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl(
                                     ClassScopeFunctionSpecializationDecl *D) {
   VisitDecl(D);

test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp

   return X0<X2>::value; // expected-note{{instantiation}}
 }
   
-template<typename T> T x; // expected-error{{variable 'x' declared as a template}}
+template<typename T> T x; // expected-warning{{variable 'x' declared as a template}}

test/SemaCXX/conversion-function.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s 
 class X { 
 public:
   operator bool();

test/SemaCXX/cxx1y-variable-templates.cpp

+// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s
+
+// Only top-level variable templates for now.
+
+namespace top_level_decls {
+  template<typename T> 
+  T pi = T(3.1415926535897932385); // expected-note {{template is declared here}}
+
+  template<typename T> 
+  constexpr T cpi = T(3.1415926535897932385); // expected-note {{template is declared here}}
+  
+  namespace use_in_top_level_funcs {
+    void good() {
+      int ipi = pi<int>;
+      int icpi = cpi<int>;
+      double dpi = pi<double>;
+      double dcpi = cpi<double>;
+    }
+    
+    void no_deduce() {
+      // template arguments are not deduced for uses of variable templates.
+      int ipi = pi; // expected-error {{cannot refer to variable template 'pi' without a template argument list}}
+      int icpi = cpi; // expected-error {{cannot refer to variable template 'cpi' without a template argument list}}
+    }
+    
+    template<typename T>
+    T circular_area(T r) {
+      return pi<T> * r * r;
+    }
+    
+    template<typename T>
+    constexpr T const_circular_area(T r) {
+      return cpi<T> * r * r;
+    }
+    
+    double use_circular_area(double r) {
+      static_assert(const_circular_area(2) == 12, "");
+      
+      constexpr float t = const_circular_area(2.0) - 12;
+      constexpr int test = (t > 0) && (t < 1);
+      static_assert(test, "");
+      
+      return circular_area(r);
+    }
+  }
+  
+  namespace use_in_structs {
+    // TODO: 
+  }
+   
+  namespace shadow {
+    void foo() {
+      int ipi0 = pi<int>;
+      int pi;
+      int a = pi;
+      int ipi = pi<int>;  // expected-error {{expected '(' for function-style cast or type construction}} \
+                          // expected-error {{expected expression}}
+    }
+  }
+  
+  // No forward declaration for variables templates.
+  namespace odr {
+    namespace one {
+      int v;   // expected-note {{previous definition is here}}
+      template<typename T> T v; // expected-error {{redefinition of 'v' as different kind of symbol}}
+    }
+    namespace two {
+      template<typename T> T v; // expected-note {{previous definition is here}}
+      int v;   // expected-error {{redefinition of 'v' as different kind of symbol}}
+    }
+    namespace three {
+      template<typename T> T v; // expected-note {{previous definition is here}}
+      template<typename T> T v; // expected-error {{redefinition of 'v'}}
+    }
+    namespace four {
+      template<typename T> T v;
+      v = 10;  // expected-error {{C++ requires a type specifier for all declarations}}
+    }
+  }  
+    
+  namespace attributes {
+    // TODO:
+  }
+  
+  namespace arrays {
+    // TODO:
+  }
+
+  namespace explicit_instantiation {
+    template<typename T> 
+    T pi0 = T(3.1415926535897932385);  // expected-note 3{{variable template 'pi0' declared here}}
+
+    template float pi0<int>; // expected-error {{type 'float' of explicit instantiation does not match expected type 'int'}}
+    template constexpr int pi0<int>; // expected-error {{type 'const int' of explicit instantiation does not match expected type 'int'}}
+    template int pi0<const int>;  // expected-error {{type 'int' of explicit instantiation does not match expected type 'const int'}}
+    
+    template int pi0<int>;   // expected-note {{previous explicit instantiation is here}}
+    template int pi0<int>;   // expected-error {{duplicate explicit instantiation of 'pi0<int>'}}
+    
+    template<typename T> 
+    constexpr T pi1 = T(3.1415926535897932385);  // expected-note {{variable template 'pi1' declared here}} \
+                                                 // expected-note {{variable template 'pi1' declared here}}
+    
+    template int pi1<int>; // expected-error {{type 'int' of explicit instantiation does not match expected type 'const int'}}
+    template int pi1<const int>;  // expected-error {{type 'int' of explicit instantiation does not match expected type 'const const int'}}
+    
+    template constexpr int pi1<int>;   // expected-note {{previous explicit instantiation is here}}
+    template constexpr int pi1<int>;   // expected-error {{duplicate explicit instantiation of 'pi1<int>'}}
+ 
+  }
+  
+  namespace explicit_specialization {
+    namespace good {
+      template<typename T1, typename T2>
+      constexpr int pi2 = 1;
+
+      template<typename T>
+      constexpr int pi2<T,int> = 2;
+
+      template<typename T>
+      constexpr int pi2<int,T> = 3;
+
+      template<> constexpr int pi2<int,int> = 4;
+      
+      void foo() {
+        static_assert(pi2<int,int> == 4, "");
+        static_assert(pi2<float,int> == 2, "");
+        static_assert(pi2<int,float> == 3, "");
+        static_assert(pi2<int,float> == pi2<int,double>, "");
+        static_assert(pi2<float,float> == 1, "");
+        static_assert(pi2<float,float> == pi2<float,double>, "");
+      } 
+    }
+
+    namespace ambiguous {
+      template<typename T1, typename T2>
+      constexpr int pi2 = 1;
+
+      template<typename T>
+      constexpr int pi2<T,int> = 2; // expected-note {{partial specialization matches [with T = int]}}
+
+      template<typename T>
+      constexpr int pi2<int,T> = 3; // expected-note {{partial specialization matches [with T = int]}}
+      
+      void foo() {
+        int a = pi2<int,int>;  // expected-error {{ambiguous partial specializations of 'pi2<int, int>'}}
+      } 
+    }
+    
+    namespace type_mismatch {
+      template<typename T> 
+      T pi0 = T(3.1415926535897932385);  // expected-note 3{{variable template 'pi0' declared here}}
+
+      template<> float pi0<int> = 10; // expected-error {{type 'float' of explicit specialization does not match expected type 'int'}}
+      template<> constexpr int pi0<int> = 10; // expected-error {{type 'const int' of explicit specialization does not match expected type 'int'}}
+      template<> int pi0<const int> = 10;  // expected-error {{type 'int' of explicit specialization does not match expected type 'const int'}}
+      
+      template<typename T> 
+      constexpr T pi1 = T(3.1415926535897932385);  //expected-note {{variable template 'pi1' declared here}}
+      
+      template<> int pi1<int> = 10; // expected-error {{type 'int' of explicit specialization does not match expected type 'const int'}}
+    }
+    
+    namespace duplicate {
+      template<typename T> 
+      T pi0 = T(3.1415926535897932385);
+
+      template<> int pi0<int> = 10;   // expected-note {{previous definition is here}}
+      template<> int pi0<int> = 10;   // expected-error {{redefinition of 'pi0<int>'}}
+
+      template<typename T> 
+      constexpr T pi1 = T(3.1415926535897932385);
+
+      template<> constexpr int pi1<int> = 10;   // expected-note {{previous definition is here}}
+      template<> constexpr int pi1<int> = 10;   // expected-error {{redefinition of 'pi1<int>'}}
+    }
+    
+    namespace before_instantiation {
+      template<typename T> 
+      T pi0 = T(3.1415926535897932385);
+
+      template<> int pi0<int> = 10;
+      template int pi0<int>;
+
+      template<typename T1, typename T2>
+      constexpr int pi2 = 1;
+
+      template<typename T> constexpr int pi2<T,int> = 2;
+      template constexpr int pi2<int,int>;
+    }
+    namespace after_instantiation {
+      template<typename T> 
+      T pi0 = T(3.1415926535897932385);
+
+      template int pi0<int>;   // expected-note {{explicit instantiation first required here}}
+      template<> int pi0<int> = 10;  // expected-error {{explicit specialization of 'pi0' after instantiation}}
+      
+      template<typename T1, typename T2>
+      constexpr int pi2 = 1;
+
+      template constexpr int pi2<int,int>;
+      template<typename T> constexpr int pi2<T,int> = 2;
+    }
+  }
+}
+
+namespace static_members_only {
+  // TODO:
+}

test/SemaCXX/for-range-examples.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 
 
 namespace value_range_detail {
   template<typename T>

test/SemaCXX/unknown-type-name.cpp

 template<typename T> int h(T::type, int); // expected-error{{missing 'typename'}}
 template<typename T> int h(T::type x, char); // expected-error{{missing 'typename'}}
 
-template<typename T> int junk1(T::junk); // expected-error{{declared as a template}}
+template<typename T> int junk1(T::junk); // expected-warning{{declared as a template}}
 template<typename T> int junk2(T::junk) throw(); // expected-error{{missing 'typename'}}
 template<typename T> int junk3(T::junk) = delete; // expected-error{{missing 'typename'}} expected-warning{{C++11}}
 template<typename T> int junk4(T::junk j); // expected-error{{missing 'typename'}}
 
 // FIXME: We can tell this was intended to be a function because it does not
 //        have a dependent nested name specifier.
-template<typename T> int i(T::type, int()); // expected-error{{variable 'i' declared as a template}}
+template<typename T> int i(T::type, int()); // expected-warning{{variable 'i' declared as a template}}
 
 // FIXME: We know which type specifier should have been specified here. Provide
 //        a fix-it to add 'typename A<T>::type'

test/SemaTemplate/class-template-decl.cpp

   template<typename T> class X; // expected-error{{expression}}
 }
 
-template<typename T> class X1 var; // expected-error{{declared as a template}}
+template<typename T> class X1 var; // expected-warning{{declared as a template}}
 
 namespace M {
 }

tools/libclang/CIndex.cpp

     return clang_getNullCursor();
   }
 
-  case Decl::Var: {
+  case Decl::Var: 
+  case Decl::VarTemplateSpecialization:
+  case Decl::VarTemplatePartialSpecialization: {
     // Ask the variable if it has a definition.
     if (const VarDecl *Def = cast<VarDecl>(D)->getDefinition())
       return MakeCXCursor(Def, TU);

                           TU);
     return clang_getNullCursor();
   }
+  
+  case Decl::VarTemplate: {
+    if (VarDecl *Def = cast<VarTemplateDecl>(D)->getTemplatedDecl()
+                                                            ->getDefinition())
+      return MakeCXCursor(cast<VarDecl>(Def)->getDescribedVarTemplate(),
+                          TU);
+    return clang_getNullCursor();
+  }
 
   case Decl::Using:
     return MakeCursorOverloadedDeclRef(cast<UsingDecl>(D), 

tools/libclang/RecursiveASTVisitor.h

   // These are helper methods used by more than one Traverse* method.
   bool TraverseTemplateParameterListHelper(TemplateParameterList *TPL);
   bool TraverseClassInstantiations(ClassTemplateDecl *D);
+  bool TraverseVariableInstantiations(VarTemplateDecl *D);
   bool TraverseFunctionInstantiations(FunctionTemplateDecl *D) ;
   bool TraverseTemplateArgumentLocsHelper(const TemplateArgumentLoc *TAL,
                                           unsigned Count);

     // it was instantiated, and thus should not be traversed.
   })
 
+// A helper method for traversing the implicit instantiations of a
+// class template.
+template<typename Derived>
+bool RecursiveASTVisitor<Derived>::TraverseVariableInstantiations(
+    VarTemplateDecl *D) {
+  VarTemplateDecl::spec_iterator end = D->spec_end();
+  for (VarTemplateDecl::spec_iterator it = D->spec_begin(); it != end; ++it) {
+    VarTemplateSpecializationDecl* SD = *it;
+
+    switch (SD->getSpecializationKind()) {
+    // Visit the implicit instantiations with the requested pattern.
+    case TSK_Undeclared:
+    case TSK_ImplicitInstantiation:
+      TRY_TO(TraverseDecl(SD));
+      break;
+
+    // We don't need to do anything on an explicit instantiation
+    // or explicit specialization because there will be an explicit
+    // node for it elsewhere.
+    case TSK_ExplicitInstantiationDeclaration:
+    case TSK_ExplicitInstantiationDefinition:
+    case TSK_ExplicitSpecialization:
+      break;
+    }
+  }
+
+  return true;
+}
+
+DEF_TRAVERSE_DECL(VarTemplateDecl, {
+    VarDecl* TempDecl = D->getTemplatedDecl();
+    TRY_TO(TraverseDecl(TempDecl));
+    TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
+
+    // By default, we do not traverse the instantiations of
+    // variable templates since they do not appear in the user code. The
+    // following code optionally traverses them.
+    //
+    // We only traverse the variable instantiations when we see the canonical
+    // declaration of the template, to ensure we only visit them once.
+    if (getDerived().shouldVisitTemplateInstantiations() &&
+        D == D->getCanonicalDecl())
+      TRY_TO(TraverseVariableInstantiations(D));
+
+    // Note that getInstantiatedFromMemberTemplate() is just a link
+    // from a template instantiation back to the template from which
+    // it was instantiated, and thus should not be traversed.
+  })
+
 // A helper method for traversing the instantiations of a
 // function while skipping its specializations.
 template<typename Derived>

     TRY_TO(TraverseVarHelper(D));
   })
 
+DEF_TRAVERSE_DECL(VarTemplateSpecializationDecl, {
+    // For implicit instantiations, we don't want to
+    // recurse at all, since the instatiated class isn't written in
+    // the source code anywhere.
+    if (TypeSourceInfo *TSI = D->getTypeAsWritten())
+      TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
+
+    if (!getDerived().shouldVisitTemplateInstantiations() &&
+        D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)
+      // Returning from here skips traversing the
+      // declaration context of the VarTemplateSpecializationDecl
+      // (embedded in the DEF_TRAVERSE_DECL() macro).
+      return true;
+  })
+
+  DEF_TRAVERSE_DECL(VarTemplatePartialSpecializationDecl, {
+      // The partial specialization.
+      if (TemplateParameterList *TPL = D->getTemplateParameters()) {
+        for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end();
+             I != E; ++I) {
+          TRY_TO(TraverseDecl(*I));
+        }
+      }
+      // The args that remains unspecialized.
+      TRY_TO(TraverseTemplateArgumentLocsHelper(
+          D->getTemplateArgsAsWritten(), D->getNumTemplateArgsAsWritten()));
+
+      // Don't need the VarTemplatePartialSpecializationHelper, even
+      // though that's our parent class -- we already visit all the
+      // template args here.
+      TRY_TO(TraverseVarHelper(D));
+
+      // Instantiations will have been visited with the primary template.
+    })
+
 DEF_TRAVERSE_DECL(ImplicitParamDecl, {
     TRY_TO(TraverseVarHelper(D));
   })