Basic method definition and invocation.

Author: marsupial

CMakeLists.txt

@@ -247,7 +247,7 @@ TESTSUITE ( and-or-not-synonyms aastep arithmetic array array-derivs array-range
             draw_string
             error-dupes exit exponential
             fprintf
-            function-earlyreturn function-simple function-outputelem
+            function-earlyreturn function-method function-simple function-outputelem
             geomath getattribute-camera getattribute-shader
             getsymbol-nonheap gettextureinfo
             group-outputs groupstring
@@ -266,7 +266,7 @@ TESTSUITE ( and-or-not-synonyms aastep arithmetic array array-derivs array-range
             operator-overloading
             oslc-comma oslc-D
             oslc-err-arrayindex oslc-err-closuremul oslc-err-field
-            oslc-err-format oslc-err-intoverflow
+            oslc-err-format oslc-err-intoverflow oslc-err-method
             oslc-err-names oslc-err-noreturn oslc-err-notfunc
             oslc-err-outputparamvararray oslc-err-paramdefault
             oslc-err-struct-array-init oslc-err-struct-ctr

src/include/osl_pvt.h

@@ -557,6 +557,10 @@ class Symbol {
         m_alias = other;
     }
 
+    /// Get a reference to whatever this symbol aliases.
+    ///
+    const Symbol* alias () const { return m_alias; }
+
     /// Return a string representation ("param", "global", etc.) of the
     /// SymType s.
     static const char *symtype_shortname (SymType s);

src/liboslcomp/ast.cpp

@@ -285,14 +285,15 @@ ASTnamed_symbol::ASTnamed_symbol (NodeType node_type, OSLCompilerImpl *comp,
 
 
 bool
-ASTnamed_symbol::check_reserved (ustring name, OSLCompilerImpl *comp)
+ASTnamed_symbol::check_reserved (ustring name, OSLCompilerImpl *comp,
+                                 int vflags)
 {
     if (Strutil::starts_with(name, "___")) {
         comp->error (comp->filename(), comp->lineno(),
                      "'%s' : sorry, can't start with three underscores",
                      name);
         return false;
-    } else if (name == "this") {
+    } else if (!(vflags & allow_this) && name == "this") {
         comp->error (comp->filename(), comp->lineno(),
                      "'this' not allowed in this context");
         return false;
@@ -317,9 +318,9 @@ ASTnamed_symbol::previous_decl (ASTNode* node)
 
 Symbol*
 ASTnamed_symbol::validate (ustring name, OSLCompilerImpl *comp,
-                           Validation vflags, int allowed)
+                           int vflags, int allowed)
 {
-    check_reserved (name, comp);
+    check_reserved (name, comp, vflags);
 
     Symbol *f;
 	bool shadow = vflags & warn_shadow;
@@ -341,19 +342,35 @@ ASTnamed_symbol::validate (ustring name, OSLCompilerImpl *comp,
         if (! f || f->symtype() == allowed)
             return f;
 
-        std::string e = Strutil::format ("'%s' already declared in this scope",
-                                         name);
-        e += previous_decl (f->node());
-
+        std::string msg;
+        ASTNode* hint = f->node();
         if (shadow) {
-            // special case: only a warning for param to mask global function
+            // Downgrade to warning if param to mask global function
             shadow = f->scope() == 0 && f->symtype() == SymTypeFunction;
+
+            // also downgrade to warning if local variable shadowing a field
+            if (!shadow && f->alias() && f->alias()->node()) {
+                if (f->alias()->node()->typespec().is_structure() &&
+                    f->alias()->name() == Strutil::format("this.%s", name)) {
+                    msg = Strutil::format ("\"%s\" shadows a field with the same name",
+                                           name);
+                    // FIXME: Would be nice to hint about where the field was
+                    // declared, but f->alias()->node() is the 'this.field' node.
+                    hint = nullptr;
+                    shadow = true;
+                }
+            }
         }
 
+        if (msg.empty())
+            msg = Strutil::format ("'%s' already declared in this scope", name);
+
+        msg += previous_decl (hint);
+
         if (shadow)
-            comp->warning(comp->filename(), comp->lineno(), "%s", e);
+            comp->warning(comp->filename(), comp->lineno(), "%s", msg);
         else
-            comp->error(comp->filename(), comp->lineno(), "%s", e);
+            comp->error(comp->filename(), comp->lineno(), "%s", msg);
     }
     return f;
 }
@@ -532,17 +549,19 @@ ASTvariable_declaration::ASTvariable_declaration (OSLCompilerImpl *comp,
                                                   const TypeSpec &type,
                                                   ustring name, ASTNode *init,
                                                   bool isparam, bool ismeta,
-                                                  bool isoutput, bool initlist)
+                                                  bool isoutput, bool initlist,
+                                                  bool isthis)
     : ASTnamed_symbol (variable_declaration_node, comp, name, init, NULL /* meta */),
       m_isparam(isparam), m_isoutput(isoutput), m_ismetadata(ismeta),
       m_initlist(initlist)
 {
-    if (! check_reserved ())
+    int vflags = isthis ? allow_this : 0;
+    if (! check_reserved (m_name, m_compiler, vflags))
         return;
 
     m_typespec = type;
     if (! m_ismetadata)
-        validate (warn_function_clash);
+        validate (vflags | warn_function_clash);
 
     SymType symtype = isparam ? (isoutput ? SymTypeOutputParam : SymTypeParam)
                               : SymTypeLocal;
@@ -566,6 +585,50 @@ ASTvariable_declaration::ASTvariable_declaration (OSLCompilerImpl *comp,
 
 
 
+ASTvariable_declaration::ASTvariable_declaration (OSLCompilerImpl *comp,
+                                                  const TypeSpec &type,
+                                                  ASTNode *args)
+    : ASTvariable_declaration(comp, type, ustring("this"), NULL,
+                              false, false, false, false, true)
+{
+    // Push 'this' to front of given arguments
+    concat(this, args);
+    if (StructSpec* sspec = type.structure() ? type.structspec() : nullptr) {
+        // Add the fields as accessible without 'this', warning about possible
+        // shadowing/ambiguity as we go.
+        for (int i = 0, n = sspec->numfields(); i < n; ++i) {
+            const auto& field = sspec->field(i);
+            bool conflict = false;
+            for (ref next = args; next; next = next->next()) {
+                ASSERT (next->nodetype() == variable_declaration_node);
+                auto *arg = static_cast<ASTvariable_declaration*>(next.get());
+
+                if (arg->name() == field.name) {
+                    warning ("argument \"%s\" shadows a field with the same name",
+                             field.name);
+                    conflict = true;
+                    break;
+                }
+            }
+            if (! conflict) {
+                ustring qualname = ustring::format ("this.%s", field.name);
+                ASSERT (m_compiler->symtab().find (qualname) != nullptr);
+                ASSERT (!m_compiler->symtab().find (field.name) ||
+                         m_compiler->symtab().find (field.name)->scope() !=
+                         m_compiler->symtab().scopeid());
+
+                Symbol* qsym = m_compiler->symtab().find (qualname);
+                Symbol *fsym = new Symbol (field.name, field.type,
+                                           qsym->symtype (), this);
+                fsym->alias (qsym);
+                m_compiler->symtab().insert (fsym);
+            }
+        }
+    }
+}
+
+
+
 const char *
 ASTvariable_declaration::nodetypename () const
 {
@@ -603,10 +666,10 @@ ASTvariable_declaration::print (std::ostream &out, int indentlevel) const
 
 
 
-ASTvariable_ref::ASTvariable_ref (OSLCompilerImpl *comp, ustring name)
+ASTvariable_ref::ASTvariable_ref (OSLCompilerImpl *comp, ustring name, bool allowthis)
     : ASTnamed_symbol (variable_ref_node, comp, name)
 {
-    m_sym = validate (warn_function_exists);
+    m_sym = validate (warn_function_exists | (allowthis ? allow_this : 0));
     if (m_sym)
         m_typespec = m_sym->typespec();
 }
@@ -1122,10 +1185,11 @@ ASTtype_constructor::childname (size_t i) const
 ASTfunction_call::ASTfunction_call (OSLCompilerImpl *comp, ustring name,
                                     ASTNode *args, FunctionSymbol *funcsym)
     : 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
-      m_argwrite(1),      // Default - first arg only is written by the op
-      m_argtakesderivs(0) // Default - doesn't take derivs
+      m_poly(funcsym),     // Default - resolved symbol or null
+      m_argread(~1),       // Default - all args are read except the first
+      m_argwrite(1),       // Default - first arg only is written by the op
+      m_argtakesderivs(0), // Default - doesn't take derivs
+      m_method(false)
 {
     m_sym = funcsym ? funcsym : validate (err_must_exist); // Look it up.
     if (! m_sym || is_struct_ctr())
@@ -1139,10 +1203,24 @@ ASTfunction_call::ASTfunction_call (OSLCompilerImpl *comp, ustring name,
 
 
 
+void
+ASTfunction_call::method_from_function (ASTNode* thisRef)
+{
+    ASSERT (m_method == false);
+    ASSERT (m_children.size() == 1);
+    m_method = true;
+    if (m_children[0])
+        thisRef->append(args().get());
+
+    m_children[0] = thisRef;
+}
+
+
+
 const char *
 ASTfunction_call::childname (size_t i) const
 {
-    return ustring::format ("param%d", (int)i).c_str();
+    return (i || !m_method ? ustring::format ("param%d", (int)i) : ustring("this")).c_str();
 }
 
 

src/liboslcomp/ast.h

@@ -301,7 +301,8 @@ class ASTNode : public OIIO::RefCnt {
     /// Type check a list (whose head is given by 'arg' against the list
     /// of expected types given in encoded form by 'formals'.
     bool check_arglist (const char *funcname, ref arg,
-                        const char *formals, bool coerce=false);
+                        const char *formals, bool coerce=false,
+                        bool methcall = false);
 
     /// Follow a list of nodes, generating code for each in turn, and return
     /// the Symbol* for the last thing generated.
@@ -416,26 +417,28 @@ class ASTnamed_symbol : public ASTNode
         err_must_exist  = 0,  ///< Error when the named Symbol does not exist.
         check_clashes   = 1,  ///< If named Symbol exists error as a clash.
         warn_shadow     = 2,  ///< Warn if name shadows a known function.
+        allow_this      = 4,  ///< Allow m_name to be 'this'
 
         /// Convenient aliases of validation schemes.
         warn_function_exists = err_must_exist | warn_shadow,
         warn_function_clash  = check_clashes | warn_shadow,
     };
 
     /// Validate that m_name is a legal name.
-    static bool check_reserved (ustring name, OSLCompilerImpl *comp);
+    static bool check_reserved (ustring name, OSLCompilerImpl *comp,
+                                int allowThis = 0);
 
     /// Validate that m_name is a legal name, and doesn't conflict with rules
     /// given in vflags allowing duplicate symbol if its SymType matches allowed.
     static Symbol* validate (ustring name, OSLCompilerImpl *comp,
-                             Validation vflags, int allowed = -1);
+                             int vflags, int allowed = -1);
 
 protected:
     bool check_reserved () {
         return ASTnamed_symbol::check_reserved (m_name, m_compiler);
     }
 
-    Symbol* validate (Validation vflags, int allowed = -1) {
+    Symbol* validate (int vflags, int allowed = -1) {
         return validate (m_name, m_compiler, vflags, allowed);
     }
 
@@ -503,7 +506,11 @@ class ASTvariable_declaration : public ASTnamed_symbol
     ASTvariable_declaration (OSLCompilerImpl *comp, const TypeSpec &type,
                              ustring name, ASTNode *init, bool isparam=false,
                              bool ismeta=false, bool isoutput=false,
-                             bool initlist=false);
+                             bool initlist=false, bool isthis=false);
+
+    ASTvariable_declaration (OSLCompilerImpl *comp, const TypeSpec &type,
+                             ASTNode *args);
+
     const char *nodetypename () const;
     const char *childname (size_t i) const;
     void print (std::ostream &out, int indentlevel=0) const;
@@ -550,7 +557,7 @@ class ASTvariable_declaration : public ASTnamed_symbol
 class ASTvariable_ref : public ASTnamed_symbol
 {
 public:
-    ASTvariable_ref (OSLCompilerImpl *comp, ustring name);
+    ASTvariable_ref (OSLCompilerImpl *comp, ustring name, bool allowthis);
     const char *nodetypename () const { return "variable_ref"; }
     const char *childname (size_t i) const { return ""; } // no children
     void print (std::ostream &out, int indentlevel=0) const;
@@ -929,6 +936,8 @@ class ASTfunction_call : public ASTnamed_symbol
         return (ASTfunction_declaration *) func()->node();
     }
 
+    void method_from_function(ASTNode* thisRef);
+
 private:
     /// Typecheck all polymorphic versions, return UNKNOWN if no match was
     /// found, or a real type if there was a match.  Also, upon matching,
@@ -1013,10 +1022,13 @@ class ASTfunction_call : public ASTnamed_symbol
                                  ustring formal, ustring actual,
                                  Symbol *arrayindex = NULL);
 
+protected:
+
     FunctionSymbol *m_poly;         ///< The specific polymorphic variant
     unsigned int m_argread;         ///< Bit field - which args are read
     unsigned int m_argwrite;        ///< Bit field - which args are written
     unsigned int m_argtakesderivs;  ///< Bit field - which args take derivs
+    bool m_method;
 };