genericSignatures.hpp

/*
 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#ifndef SHARE_VM_CLASSFILE_GENERICSIGNATURES_HPP
#define SHARE_VM_CLASSFILE_GENERICSIGNATURES_HPP

#include "classfile/symbolTable.hpp"
#include "memory/allocation.hpp"
#include "runtime/signature.hpp"
#include "utilities/growableArray.hpp"
#include "utilities/resourceHash.hpp"

class stringStream;

namespace generic {

class Identifier;
class ClassDescriptor;
class MethodDescriptor;

class TypeParameter; // a formal type parameter declared in generic signatures
class TypeArgument;  // The "type value" passed to fill parameters in supertypes
class TypeVariable;  // A usage of a type parameter as a value
/**
 * Example:
 *
 * <T, V> class Foo extends Bar<String> { int m(V v) {} }
 * ^^^^^^                       ^^^^^^          ^^
 * type parameters            type argument    type variable
 *
 * Note that a type variable could be passed as an argument too:
 * <T, V> class Foo extends Bar<T> { int m(V v) {} }
 *                             ^^^
 *                             type argument's value is a type variable
 */


class Type;
class ClassType;
class ArrayType;
class PrimitiveType;
class Context;
class DescriptorCache;

class DescriptorStream;

class Identifier : public ResourceObj {
 private:
  Symbol* _sym;
  int _begin;
  int _end;

 public:
  Identifier(Symbol* sym, int begin, int end) :
    _sym(sym), _begin(begin), _end(end) {}

  bool equals(Identifier* other);
  bool equals(Symbol* sym);

#ifndef PRODUCT
  void print_on(outputStream* str) const;
#endif // ndef PRODUCT
};

class Descriptor : public ResourceObj {
 protected:
  GrowableArray<TypeParameter*> _type_parameters;
  ClassDescriptor* _outer_class;

  Descriptor(GrowableArray<TypeParameter*>& params,
    ClassDescriptor* outer)
    : _type_parameters(params), _outer_class(outer) {}

 public:

  ClassDescriptor* outer_class() { return _outer_class; }
  void set_outer_class(ClassDescriptor* sig) { _outer_class = sig; }

  virtual ClassDescriptor* as_class_signature() { return NULL; }
  virtual MethodDescriptor* as_method_signature() { return NULL; }

  bool is_class_signature() { return as_class_signature() != NULL; }
  bool is_method_signature() { return as_method_signature() != NULL; }

  GrowableArray<TypeParameter*>& type_parameters() {
    return _type_parameters;
  }

  TypeParameter* find_type_parameter(Identifier* id, int* param_depth);

  virtual void bind_variables_to_parameters() = 0;

#ifndef PRODUCT
  virtual void print_on(outputStream* str) const = 0;
#endif
};

class ClassDescriptor : public Descriptor {
 private:
  ClassType* _super;
  GrowableArray<ClassType*> _interfaces;
  MethodDescriptor* _outer_method;

  ClassDescriptor(GrowableArray<TypeParameter*>& ftp, ClassType* scs,
      GrowableArray<ClassType*>& sis, ClassDescriptor* outer_class = NULL,
      MethodDescriptor* outer_method = NULL)
        : Descriptor(ftp, outer_class), _super(scs), _interfaces(sis),
          _outer_method(outer_method) {}

  static u2 get_outer_class_index(InstanceKlass* k, TRAPS);
  static ClassDescriptor* parse_generic_signature(Klass* k, Symbol* original_name, TRAPS);

 public:

  virtual ClassDescriptor* as_class_signature() { return this; }

  MethodDescriptor* outer_method() { return _outer_method; }
  void set_outer_method(MethodDescriptor* m) { _outer_method = m; }

  ClassType* super() { return _super; }
  ClassType* interface_desc(Symbol* sym);

  static ClassDescriptor* parse_generic_signature(Klass* k, TRAPS);
  static ClassDescriptor* parse_generic_signature(Symbol* sym);

  // For use in superclass chains in positions where this is no generic info
  static ClassDescriptor* placeholder(InstanceKlass* klass);

#ifndef PRODUCT
  void print_on(outputStream* str) const;
#endif

  ClassDescriptor* canonicalize(Context* ctx);

  // Linking sets the position index in any contained TypeVariable type
  // to correspond to the location of that identifier in the formal type
  // parameters.
  void bind_variables_to_parameters();
};

class MethodDescriptor : public Descriptor {
 private:
  GrowableArray<Type*> _parameters;
  Type* _return_type;
  GrowableArray<Type*> _throws;

  MethodDescriptor(GrowableArray<TypeParameter*>& ftp, ClassDescriptor* outer,
      GrowableArray<Type*>& sigs, Type* rt, GrowableArray<Type*>& throws)
      : Descriptor(ftp, outer), _parameters(sigs), _return_type(rt),
        _throws(throws) {}

 public:

  static MethodDescriptor* parse_generic_signature(Method* m, ClassDescriptor* outer);
  static MethodDescriptor* parse_generic_signature(Symbol* sym, ClassDescriptor* outer);

  MethodDescriptor* as_method_signature() { return this; }

  // Performs generic analysis on the method parameters to determine
  // if both methods refer to the same argument types.
  bool covariant_match(MethodDescriptor* other, Context* ctx);

  // Returns a new method descriptor with all generic variables
  // removed and replaced with whatever is indicated using the Context.
  MethodDescriptor* canonicalize(Context* ctx);

  void bind_variables_to_parameters();

#ifndef PRODUCT
  TempNewSymbol reify_signature(Context* ctx, TRAPS);
  void print_on(outputStream* str) const;
#endif
};

class TypeParameter : public ResourceObj {
 private:
  Identifier* _identifier;
  ClassType* _class_bound;
  GrowableArray<ClassType*> _interface_bounds;

  // The position is the ordinal location of the parameter within the
  // formal parameter list (excluding outer classes).  It is only set for
  // formal type parameters that are associated with a class -- method
  // type parameters are left as -1.  When resolving a generic variable to
  // find the actual type, this index is used to access the generic type
  // argument in the provided context object.
  int _position; // Assigned during variable linking

  TypeParameter(Identifier* id, ClassType* class_bound,
    GrowableArray<ClassType*>& interface_bounds) :
      _identifier(id), _class_bound(class_bound),
      _interface_bounds(interface_bounds), _position(-1) {}

 public:
  static TypeParameter* parse_generic_signature(DescriptorStream* str);

  ClassType* bound();
  int position() { return _position; }

  void bind_variables_to_parameters(Descriptor* sig, int position);
  Identifier* identifier() { return _identifier; }

  Type* resolve(Context* ctx, int inner_depth, int ctx_depth);
  TypeParameter* canonicalize(Context* ctx, int ctx_depth);

#ifndef PRODUCT
  void print_on(outputStream* str) const;
#endif
};

class Type : public ResourceObj {
 public:
  static Type* parse_generic_signature(DescriptorStream* str);

  virtual ClassType* as_class() { return NULL; }
  virtual TypeVariable* as_variable() { return NULL; }
  virtual ArrayType* as_array() { return NULL; }
  virtual PrimitiveType* as_primitive() { return NULL; }

  virtual bool covariant_match(Type* gt, Context* ctx) = 0;
  virtual Type* canonicalize(Context* ctx, int ctx_depth) = 0;

  virtual void bind_variables_to_parameters(Descriptor* sig) = 0;

#ifndef PRODUCT
  virtual void reify_signature(stringStream* ss, Context* ctx) = 0;
  virtual void print_on(outputStream* str) const = 0;
#endif
};

class ClassType : public Type {
  friend class ClassDescriptor;
 protected:
  Identifier* _identifier;
  GrowableArray<TypeArgument*> _type_arguments;
  ClassType* _outer_class;

  ClassType(Identifier* identifier,
      GrowableArray<TypeArgument*>& args,
      ClassType* outer)
      : _identifier(identifier), _type_arguments(args), _outer_class(outer) {}

  // Returns true if there are inner classes to read
  static Identifier* parse_generic_signature_simple(
      GrowableArray<TypeArgument*>* args,
      bool* has_inner, DescriptorStream* str);

  static ClassType* parse_generic_signature(ClassType* outer,
      DescriptorStream* str);
  static ClassType* from_symbol(Symbol* sym);

 public:
  ClassType* as_class() { return this; }

  static ClassType* parse_generic_signature(DescriptorStream* str);
  static ClassType* java_lang_Object();

  Identifier* identifier() { return _identifier; }
  int type_arguments_length() { return _type_arguments.length(); }
  TypeArgument* type_argument_at(int i);

  virtual ClassType* outer_class() { return _outer_class; }

  bool covariant_match(Type* gt, Context* ctx);
  ClassType* canonicalize(Context* ctx, int context_depth);

  void bind_variables_to_parameters(Descriptor* sig);

#ifndef PRODUCT
  void reify_signature(stringStream* ss, Context* ctx);
  void print_on(outputStream* str) const;
#endif
};

class TypeVariable : public Type {
 private:
  Identifier* _id;
  TypeParameter* _parameter; // assigned during linking

  // how many steps "out" from inner classes, -1 if method
  int _inner_depth;

  TypeVariable(Identifier* id)
      : _id(id), _parameter(NULL), _inner_depth(0) {}

 public:
  TypeVariable* as_variable() { return this; }

  static TypeVariable* parse_generic_signature(DescriptorStream* str);

  Identifier* identifier() { return _id; }
  TypeParameter* parameter() { return _parameter; }
  int inner_depth() { return _inner_depth; }

  void bind_variables_to_parameters(Descriptor* sig);

  Type* resolve(Context* ctx, int ctx_depth);
  bool covariant_match(Type* gt, Context* ctx);
  Type* canonicalize(Context* ctx, int ctx_depth);

#ifndef PRODUCT
  void reify_signature(stringStream* ss, Context* ctx);
  void print_on(outputStream* str) const;
#endif
};

class ArrayType : public Type {
 private:
  Type* _base;

  ArrayType(Type* base) : _base(base) {}

 public:
  ArrayType* as_array() { return this; }

  static ArrayType* parse_generic_signature(DescriptorStream* str);

  bool covariant_match(Type* gt, Context* ctx);
  ArrayType* canonicalize(Context* ctx, int ctx_depth);

  void bind_variables_to_parameters(Descriptor* sig);

#ifndef PRODUCT
  void reify_signature(stringStream* ss, Context* ctx);
  void print_on(outputStream* str) const;
#endif
};

class PrimitiveType : public Type {
  friend class Type;
 private:
  char _type; // includes V for void

  PrimitiveType(char& type) : _type(type) {}

 public:
  PrimitiveType* as_primitive() { return this; }

  bool covariant_match(Type* gt, Context* ctx);
  PrimitiveType* canonicalize(Context* ctx, int ctx_depth);

  void bind_variables_to_parameters(Descriptor* sig);

#ifndef PRODUCT
  void reify_signature(stringStream* ss, Context* ctx);
  void print_on(outputStream* str) const;
#endif
};

class TypeArgument : public ResourceObj {
 private:
  Type* _lower_bound;
  Type* _upper_bound; // may be null or == _lower_bound

  TypeArgument(Type* lower_bound, Type* upper_bound)
      : _lower_bound(lower_bound), _upper_bound(upper_bound) {}

 public:

  static TypeArgument* parse_generic_signature(DescriptorStream* str);

  Type* lower_bound() { return _lower_bound; }
  Type* upper_bound() { return _upper_bound; }

  void bind_variables_to_parameters(Descriptor* sig);
  TypeArgument* canonicalize(Context* ctx, int ctx_depth);

  bool covariant_match(TypeArgument* a, Context* ctx);

#ifndef PRODUCT
  void print_on(outputStream* str) const;
#endif
};


class Context : public ResourceObj {
 private:
  DescriptorCache* _cache;
  GrowableArray<ClassType*> _type_arguments;

  void reset_to_mark(int size);

 public:
  // When this object goes out of scope or 'destroy' is
  // called, then the application of the type to the
  // context is wound-back (unless it's been deactivated).
  class Mark : public StackObj {
   private:
    mutable Context* _context;
    int _marked_size;

    bool is_active() const { return _context != NULL; }
    void deactivate() const { _context = NULL; }

   public:
    Mark() : _context(NULL), _marked_size(0) {}
    Mark(Context* ctx, int sz) : _context(ctx), _marked_size(sz) {}
    Mark(const Mark& m) : _context(m._context), _marked_size(m._marked_size) {
      m.deactivate(); // Ownership is transferred
    }

    Mark& operator=(const Mark& cm) {
      destroy();
      _context = cm._context;
      _marked_size = cm._marked_size;
      cm.deactivate();
      return *this;
    }

    void destroy();
    ~Mark() { destroy(); }
  };

  Context(DescriptorCache* cache) : _cache(cache) {}

  Mark mark() { return Mark(this, _type_arguments.length()); }
  void apply_type_arguments(InstanceKlass* current, InstanceKlass* super,TRAPS);

  ClassType* at_depth(int i) const;

#ifndef PRODUCT
  void print_on(outputStream* str) const;
#endif
};

/**
 * Contains a cache of descriptors for classes and methods so they can be
 * looked-up instead of reparsing each time they are needed.
 */
class DescriptorCache : public ResourceObj {
 private:
  ResourceHashtable<InstanceKlass*, ClassDescriptor*> _class_descriptors;
  ResourceHashtable<Method*, MethodDescriptor*> _method_descriptors;

 public:
  ClassDescriptor* descriptor_for(InstanceKlass* ikh, TRAPS);

  MethodDescriptor* descriptor_for(Method* mh, ClassDescriptor* cd, TRAPS);
  // Class descriptor derived from method holder
  MethodDescriptor* descriptor_for(Method* mh, TRAPS);
};

} // namespace generic

#endif // SHARE_VM_CLASSFILE_GENERICSIGNATURES_HPP