Fix nested template classes within a namespace generating uncompileable code by incorrectly adding in symbols into the symbol tables and not setting the scope correctly after the nested template was parsed

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@11727 626c5289-ae23-0410-ae9c-e8d60b6d4f22

Examples/test-suite/common.mk

@@ -330,6 +330,7 @@ CPP_TEST_CASES += \
 	template_inherit_abstract \
 	template_int_const \
 	template_methods \
+	template_nested \
 	template_nested_typemaps \
 	template_ns \
 	template_ns2 \

Examples/test-suite/java/template_nested_runme.java

@@ -0,0 +1,30 @@
+
+import template_nested.*;
+
+public class template_nested_runme {
+
+  static {
+    try {
+	System.loadLibrary("template_nested");
+    } catch (UnsatisfiedLinkError e) {
+      System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+      System.exit(1);
+    }
+  }
+
+  public static void main(String argv[]) {
+    new T_NormalTemplateNormalClass().tmethod(new NormalClass());
+    new OuterClass().T_OuterTMethodNormalClass(new NormalClass());
+
+    TemplateFuncs tf = new TemplateFuncs();
+    if (tf.T_TemplateFuncs1Int(-10) != -10)
+      throw new RuntimeException("it failed");
+    if (tf.T_TemplateFuncs2Double(-12.3) != -12.3)
+      throw new RuntimeException("it failed");
+
+    T_NestedOuterTemplateDouble tn = new T_NestedOuterTemplateDouble();
+    if (tn.hohum(-12.3) != -12.3)
+      throw new RuntimeException("it failed");
+  }
+}
+

Examples/test-suite/template_nested.i

@@ -0,0 +1,91 @@
+%module template_nested
+
+// Test nested templates - that is template classes and template methods within a class.
+
+#pragma SWIG nowarn=SWIGWARN_PARSE_NESTED_CLASS
+
+%inline %{
+
+namespace ns {
+
+  class NormalClass {
+  public:
+    NormalClass() {}
+    ~NormalClass() {}
+  };
+
+  template <class T> struct NormalTemplate {
+    void tmethod(T t) {}
+  };
+
+  class OuterClass {
+  public:
+    template <class T> struct Inner1 {
+      template <class U> struct SuperInner1 {
+        void method1(U t) {}
+      };
+      template <class V> struct SuperInner2 {
+        void method1(V t) {}
+      };
+      template <class W> void tmethod(W w) {}
+      template <class X> void tmethodAgain(X x) {}
+      template <class Y> struct SuperBase : public SuperInner1<Y> {
+        void method1(Y y) {}
+      };
+    };
+
+    template <class Z> void InnerTMethod(Z z) {}
+
+    template <class T> class Inner2 : public NormalTemplate<T> {
+    public:
+      template <class U> class SuperInner1 {
+      public:
+        SuperInner1() {}
+        void method1(U t) {}
+      };
+      template <class V> struct SuperInner2 {
+        void method1(V t) {}
+      };
+      int embeddedVar;
+      template <class X> void tmethod(X x) {}
+      template <class Y> struct SuperBase : public SuperInner1<Y> {
+        void method1(Y y) {}
+      };
+    };
+    int iii;
+  };
+  struct ABC {
+    ABC() {}
+    ~ABC() {}
+  };
+
+  struct TemplateFuncs {
+    template <class X> X templateMethod1(X x) { return x; }
+    template <class X> X templateMethod2(X x) { return x; }
+  };
+
+  template <typename UU> struct OuterTemplate {
+    template <typename VV> struct NestedInnerTemplate1 {
+      template <typename Z> void NestedInnerInnerTMethod(Z z) {}
+      void hohum() {}
+    };
+    template <typename W> void NestedInnerTMethod(UU u, W w) {}
+    template <typename VV> struct NestedInnerTemplate2 {
+      void hohum() {}
+    };
+    UU hohum(UU u) { return u; }
+    struct NestedStruct {
+      NestedStruct() {}
+      void hohum() {}
+    };
+  };
+}
+
+%}
+
+%template(T_NormalTemplateNormalClass) ns::NormalTemplate<ns::NormalClass>;
+%template(T_OuterTMethodNormalClass) ns::OuterClass::InnerTMethod<ns::NormalClass>;
+%template(T_TemplateFuncs1Int) ns::TemplateFuncs::templateMethod1<int>;
+%template(T_TemplateFuncs2Double) ns::TemplateFuncs::templateMethod2<double>;
+%template(T_NestedOuterTemplateDouble) ns::OuterTemplate<double>;
+