Push implicit this argument when calling methods from methods.

Author: marsupial

src/liboslcomp/ast.cpp

@@ -1256,7 +1256,8 @@ ASTtype_constructor::childname (size_t i) const
 
 
 ASTfunction_call::ASTfunction_call (OSLCompilerImpl *comp, ustring name,
-                                    ASTNode *args, FunctionSymbol *funcsym)
+                                    ASTNode *args, FunctionSymbol *funcsym,
+                                    ASTNode* implicit_this)
     : ASTnamed_symbol (function_call_node, comp, name, args),
       m_poly(funcsym),     // Default - resolved symbol or null
       m_argread(~1),       // Default - all args are read except the first
@@ -1272,14 +1273,29 @@ ASTfunction_call::ASTfunction_call (OSLCompilerImpl *comp, ustring name,
         m_sym = nullptr;
         return;
     }
+    if (implicit_this && m_sym->node()) {
+        int advance;
+        const char* form = static_cast<FunctionSymbol*>(m_sym)->argcodes().c_str();
+        /*TypeSpec rval = */ comp->type_from_code(form, &advance);
+        form += advance;
+        if (*form && comp->type_from_code(form) == implicit_this->typespec()) {
+            method_from_function(new ASTvariable_ref(m_compiler,
+                                                     ustring("this"), true));
+        }
+    }
 }
 
 
 
 void
 ASTfunction_call::method_from_function (ASTNode* thisRef)
 {
-    ASSERT (m_method == false);
+    // Only do this once!
+    if (m_method) {
+        delete thisRef;
+        return;
+    }
+
     ASSERT (m_children.size() == 1);
     m_method = true;
     if (m_children[0])

src/liboslcomp/ast.h

@@ -934,7 +934,8 @@ class ASTfunction_call : public ASTnamed_symbol
 {
 public:
     ASTfunction_call (OSLCompilerImpl *comp, ustring name, ASTNode *args,
-                      FunctionSymbol *funcsym = nullptr);
+                      FunctionSymbol *funcsym = nullptr,
+                      ASTNode* implicit_this = nullptr);
     const char *nodetypename () const { return "function_call"; }
     const char *childname (size_t i) const;
     const char *opname () const;

src/liboslcomp/oslgram.y

@@ -64,7 +64,7 @@ TypeDesc osllextype (int lex);
 OSL_NAMESPACE_EXIT
 
 static std::stack<TypeSpec> typespec_stack; // just for function_declaration
-bool allowthis;
+static ASTNode::ref implicit_this;
 
 %}
 
@@ -343,22 +343,21 @@ function_declaration
           '(' formal_params_opt ')' metadata_block_opt
                 {
                     if (StructSpec *s = oslcompiler->symtab().current_struct()) {
-                        allowthis = true;
                         TypeSpec t(s->name().c_str(), 0);
-                        auto* args = new ASTvariable_declaration(oslcompiler, t,
-                                                                 $5);
-                        $<n>$ = args;
+                        implicit_this = new ASTvariable_declaration(oslcompiler, t,
+                                                                    $5);
+                        $<n>$ = implicit_this.get();
                     } else
                         $<n>$ = $5;
                 }
           function_body_or_just_decl
                 {
-                    allowthis = false;
                     oslcompiler->symtab().pop ();  // restore scope
                     ASTfunction_declaration *f;
                     f = new ASTfunction_declaration (oslcompiler,
                                                      typespec_stack.top(),
                                                      ustring($2), $<n>8, $9, $7);
+                    implicit_this = nullptr;
                     oslcompiler->remember_function_decl (f);
                     typespec_stack.pop ();
                     $$ = f;
@@ -790,7 +789,7 @@ variable_lvalue
 id_or_field
         : IDENTIFIER 
                 {
-                    $$ = new ASTvariable_ref (oslcompiler, ustring($1), allowthis);
+                    $$ = new ASTvariable_ref (oslcompiler, ustring($1), implicit_this);
                 }
         | variable_lvalue '.' IDENTIFIER
                 {
@@ -945,7 +944,8 @@ type_constructor
 function_call
         : IDENTIFIER '(' function_args_opt ')'
                 {
-                    $$ = new ASTfunction_call (oslcompiler, ustring($1), $3);
+                    $$ = new ASTfunction_call (oslcompiler, ustring($1), $3,
+                                               nullptr, implicit_this.get());
                 }
         ;
 

testsuite/function-method/ref/out.txt

@@ -1,9 +1,16 @@
-test.osl:12: warning: argument "f" shadows a field with the same name
+test.osl:16: warning: argument "f" shadows a field with the same name
+test.osl:22: warning: argument "f" shadows a field with the same name
+test.osl:27: warning: "f" shadows a field with the same name
 Compiled test.osl -> test.oso
 emethod::test: (42) (2)
 emethod::test: (42) (46)
-emethod::testchain: 40
-emethod::testchain: 36
 emethod::testchain: 28
-emethod::testchain: 12
+emethod::testchain: 24
+emethod::testchain: 16
+emethod::testchain: 0
+emethod::shadowed: (40) (3.14)
+emethod::shadowed2: 40 22.4 6.28
+emethod::shadowed: (40) (6.28)
+unshadowed 5
+unshadowed *
 

testsuite/function-method/test.osl

@@ -1,3 +1,6 @@
+void unshadowed(int i) { printf("unshadowed %d\n", i); }
+void unshadowed() { printf("unshadowed *\n"); }
+
 struct emethod {
     float f;
 
@@ -15,12 +18,30 @@ struct emethod {
         printf("emethod::testchain: %g\n", this.f);
         return this;
     }
+
+    void shadowed(float f) {
+        printf("emethod::shadowed: (%g) (%g)\n", this.f, f);
+    }
+
+    float shadowed2(float ff) {
+        float f = 32.4;
+        f -= 10;
+        printf("emethod::shadowed2: %g %g %g\n", this.f, f, ff);
+        shadowed(ff);
+        unshadowed(5);
+        unshadowed();
+        return f;
+    }
 };
 
+
 shader test ()
 {
     emethod e = { 42 };
     e.test(2);
     e.test2(2);
     emethod(2+4+8+16).testchain(2).testchain(4).testchain(8).testchain(16);
+    e.f -= 2;
+    e.shadowed(3.14);
+    e.shadowed2(6.28);
 }