--- a/libinterp/parse-tree/pt-idx.h	Thu Jan 19 14:47:19 2017 -0500
+++ b/libinterp/parse-tree/pt-idx.h	Thu Jan 19 23:41:54 2017 -0500
@@ -27,10 +27,6 @@
 
 #include <list>
 
-class tree_argument_list;
-
-class tree_walker;
-
 class octave_map;
 class octave_value;
 class octave_value_list;
@@ -41,95 +37,107 @@
 #include "pt-exp.h"
 #include "symtab.h"
 
-// Index expressions.
-
-class
-tree_index_expression : public tree_expression
+namespace octave
 {
-public:
+  class tree_argument_list;
 
-  tree_index_expression (tree_expression *e = 0, tree_argument_list *lst = 0,
-                         int l = -1, int c = -1, char t = '(');
+  class tree_walker;
+
+  // Index expressions.
 
-  tree_index_expression (tree_expression *e, const std::string& n,
-                         int l = -1, int c = -1);
+  class tree_index_expression : public tree_expression
+  {
+  public:
 
-  tree_index_expression (tree_expression *e, tree_expression* df,
-                         int l = -1, int c = -1);
+    tree_index_expression (tree_expression *e = 0, tree_argument_list *lst = 0,
+                           int l = -1, int c = -1, char t = '(');
 
-  // No copying!
+    tree_index_expression (tree_expression *e, const std::string& n,
+                           int l = -1, int c = -1);
 
-  tree_index_expression (const tree_index_expression&) = delete;
+    tree_index_expression (tree_expression *e, tree_expression* df,
+                           int l = -1, int c = -1);
 
-  tree_index_expression& operator = (const tree_index_expression&) = delete;
+    // No copying!
 
-  ~tree_index_expression (void);
+    tree_index_expression (const tree_index_expression&) = delete;
+
+    tree_index_expression& operator = (const tree_index_expression&) = delete;
 
-  bool has_magic_end (void) const;
+    ~tree_index_expression (void);
 
-  void append (tree_argument_list *lst = 0, char t = '(');
+    bool has_magic_end (void) const;
 
-  void append (const std::string& n);
+    void append (tree_argument_list *lst = 0, char t = '(');
 
-  void append (tree_expression *df);
+    void append (const std::string& n);
 
-  bool is_index_expression (void) const { return true; }
+    void append (tree_expression *df);
 
-  std::string name (void) const;
+    bool is_index_expression (void) const { return true; }
 
-  tree_expression *expression (void) { return expr; }
+    std::string name (void) const;
 
-  std::list<tree_argument_list *> arg_lists (void) { return args; }
+    tree_expression *expression (void) { return expr; }
 
-  std::string type_tags (void) { return type; }
+    std::list<tree_argument_list *> arg_lists (void) { return args; }
 
-  std::list<string_vector> arg_names (void) { return arg_nm; }
+    std::string type_tags (void) { return type; }
 
-  bool lvalue_ok (void) const { return expr->lvalue_ok (); }
+    std::list<string_vector> arg_names (void) { return arg_nm; }
 
-  bool rvalue_ok (void) const { return true; }
+    bool lvalue_ok (void) const { return expr->lvalue_ok (); }
 
-  octave_value rvalue1 (int nargout = 1);
+    bool rvalue_ok (void) const { return true; }
 
-  octave_value_list rvalue (int nargout);
+    octave_value rvalue1 (int nargout = 1);
 
-  octave_value_list rvalue (int nargout,
-                            const std::list<octave_lvalue> *lvalue_list);
+    octave_value_list rvalue (int nargout);
 
-  octave_lvalue lvalue (void);
+    octave_value_list rvalue (int nargout,
+                              const std::list<octave_lvalue> *lvalue_list);
 
-  tree_index_expression *dup (symbol_table::scope_id scope,
-                              symbol_table::context_id context) const;
+    octave_lvalue lvalue (void);
 
-  void accept (tree_walker& tw);
+    tree_index_expression *dup (symbol_table::scope_id scope,
+                                symbol_table::context_id context) const;
 
-private:
+    void accept (tree_walker& tw);
 
-  // The LHS of this index expression.
-  tree_expression *expr;
+  private:
+
+    // The LHS of this index expression.
+    tree_expression *expr;
 
-  // The indices (only valid if type == paren || type == brace).
-  std::list<tree_argument_list *> args;
+    // The indices (only valid if type == paren || type == brace).
+    std::list<tree_argument_list *> args;
 
-  // The type of this index expression.
-  std::string type;
+    // The type of this index expression.
+    std::string type;
 
-  // The names of the arguments.  Used for constant struct element
-  // references.
-  std::list<string_vector> arg_nm;
+    // The names of the arguments.  Used for constant struct element
+    // references.
+    std::list<string_vector> arg_nm;
 
-  // The list of dynamic field names, if any.
-  std::list<tree_expression *> dyn_field;
+    // The list of dynamic field names, if any.
+    std::list<tree_expression *> dyn_field;
 
-  tree_index_expression (int l, int c);
+    tree_index_expression (int l, int c);
 
-  octave_map make_arg_struct (void) const;
+    octave_map make_arg_struct (void) const;
 
-  std::string
-  get_struct_index
+    std::string
+    get_struct_index
     (std::list<string_vector>::const_iterator p_arg_nm,
      std::list<tree_expression *>::const_iterator p_dyn_field) const;
-};
+  };
+}
+
+#if defined (OCTAVE_USE_DEPRECATED_FUNCTIONS)
+
+OCTAVE_DEPRECATED ("use 'octave::tree_index_expression' instead")
+typedef octave::tree_index_expression tree_index_expression;
 
 #endif
 
+#endif