diff --git a/lib/jsduck/api_exporter.rb b/lib/jsduck/api_exporter.rb
index 7e7e37b1bc500a531c2b37aa6a62aa81c91a3e14..65e3e037d2bad491a822fcc172795bf566704aaf 100644
--- a/lib/jsduck/api_exporter.rb
+++ b/lib/jsduck/api_exporter.rb
@@ -28,17 +28,17 @@ module JsDuck
     def export(cls)
       {
         :name => cls[:name],
-        :members => export_members(cls, :members),
-        :statics => export_members(cls, :statics),
+        :members => export_members(cls, false),
+        :statics => export_members(cls, true),
       }
     end
 
     private
 
-    def export_members(cls, context)
+    def export_members(cls, static)
       h = {}
       Class.default_members_hash.each_key do |type|
-        h[type] = cls.members(type, context).map {|m| m[:name] }
+        h[type] = cls.find_members(:tagname => type, :static => static).map {|m| m[:name] }
       end
       h
     end
diff --git a/lib/jsduck/class.rb b/lib/jsduck/class.rb
index a0329f7391fc8674e5389db685b973ef653b37c5..c0a52b5952492c1a2eb639ac623bd7d3ef9a710e 100644
--- a/lib/jsduck/class.rb
+++ b/lib/jsduck/class.rb
@@ -114,73 +114,6 @@ module JsDuck
       return full_name == class_name || (parent ? parent.inherits_from?(class_name) : false)
     end
 
-    # Returns array of all public members of particular type in a class,
-    # sorted by name.
-    #
-    # For methods the the constructor is listed first.
-    #
-    # See members_hash for details.
-    def members(type, context=:members)
-      ms = members_hash(type, context).values
-      ms.sort! {|a,b| a[:name] <=> b[:name] }
-      type == :method ? constructor_first(ms) : ms
-    end
-
-    # If methods list contains constructor, rename it with class name
-    # and move into beginning of methods list.
-    def constructor_first(ms)
-      constr = ms.find {|m| m[:name] == "constructor" }
-      if constr
-        ms.delete(constr)
-        ms.unshift(constr)
-      end
-      ms
-    end
-
-    # Returns hash of all members in class (and of parent classes
-    # and mixin classes).  Members are methods, properties, cfgs,
-    # events (member type is specified through 'type' parameter).
-    #
-    # When parent and child have members with same name,
-    # member from child overrides tha parent member.
-    def members_hash(type, context=:members)
-      # Singletons have no static members
-      if @doc[:singleton] && context == :statics
-        # Warn if singleton has static members
-        @doc[:members].each do |m|
-          if m[:meta] && m[:meta][:static]
-            ctx = m[:files][0]
-            msg = "Singleton class #{@doc[:name]} can't have static members, remove the @static tag."
-            Logger.instance.warn(:sing_static, msg, ctx[:filename], ctx[:linenr])
-          end
-        end
-        return {}
-      end
-
-      ms = parent ? parent.members_hash(type, context) : {}
-
-      mixins.each do |mix|
-        merge!(ms, mix.members_hash(type, context))
-      end
-
-      # For static members, exclude everything not explicitly marked as inheritable
-      if context == :statics
-        ms.delete_if {|key, member| !member[:inheritable] }
-      end
-
-      merge!(ms, local_members_hash(type, context))
-
-      # If singleton has static members, include them as if they were
-      # instance members.  Otherwise they will be completely excluded
-      # from the docs, as the static members block is not created for
-      # singletons.
-      if @doc[:singleton]
-        merge!(ms, local_members_hash(type, :statics))
-      end
-
-      ms
-    end
-
     # merges second members hash into first one
     def merge!(hash1, hash2, skip_overrides=false)
       hash2.each_pair do |name, m|
@@ -230,53 +163,6 @@ module JsDuck
       end
     end
 
-    # Helper method to get the direct members of this class
-    def local_members_hash(type, context)
-      is_static = (context == :statics)
-      local_members = {}
-
-      @doc[:members].find_all do |m|
-        static = (m[:meta] || {})[:static] || false
-        m[:tagname] == type && static == is_static
-      end.each do |m|
-        local_members[m[:name]] = m
-      end
-
-      local_members
-    end
-
-    # Returns members by name. An array of one or more members, or
-    # empty array when nothing matches.
-    #
-    # Optionally one can also specify type name to differenciate
-    # between different types of members.
-    #
-    # Finally static flag can be specified. True to look only at
-    # static members, false to look at instance members, and nil to
-    # look at both.
-    def get_members(name, type_name=nil, static=nil)
-      # build hash of all members
-      unless @members_map
-        @members_map = {}
-        all_members.each do |m|
-          @members_map[m[:name]] = (@members_map[m[:name]] || []) + [m]
-        end
-      end
-
-      ms = @members_map[name] || []
-      ms = ms.find_all {|m| m[:tagname] == type_name } if type_name
-      # static = true | false | nil
-      ms = ms.find_all {|m| m[:meta][:static] } if static == true
-      ms = ms.find_all {|m| !m[:meta][:static] } if static == false
-      return ms
-    end
-
-    # Call this when renaming or moving members inside class.
-    def reset_members_lookup!
-      @members_map = nil
-    end
-
-
     # Generates local members hash by ID
     def new_local_members_hash
       unless @map_by_id
@@ -293,7 +179,9 @@ module JsDuck
     # Generates global members hash by ID
     def new_global_members_hash
       unless @global_map_by_id
-        @global_map_by_id = parent ? parent.new_global_members_hash : {}
+        # Make copy of parent class members.
+        # Otherwise we'll be merging directly into parent class.
+        @global_map_by_id = parent ? parent.new_global_members_hash.clone : {}
 
         mixins.each do |mix|
           merge!(@global_map_by_id, mix.new_global_members_hash)
@@ -346,8 +234,16 @@ module JsDuck
       ms
     end
 
+    # This must be called whenever member hashes are changed.
+    # It updates the :id fields of members and clears the caches.
+    def update_members!(members)
+      members.each do |m|
+        m[:id] = Class.member_id(m)
+      end
+      invalidate_search_cache!
+    end
+
     # Clears the search cache.
-    # This is used by InheritDoc after transforming configs into properties.
     # This is also REALLY BAD - try to get rid of it.
     def invalidate_search_cache!
       @map_by_id = nil
@@ -359,17 +255,6 @@ module JsDuck
       mixins.each {|mix| mix.invalidate_search_cache! }
     end
 
-
-    # Returns all members of class, including the inherited and mixed in ones
-    def all_members
-      all = []
-      [:cfg, :property, :method, :event, :css_mixin, :css_var].each do |type|
-        all += members(type, :members)
-        all += members(type, :statics)
-      end
-      all
-    end
-
     # Returns all local members of class
     def all_local_members
       @doc[:members]
@@ -430,6 +315,13 @@ module JsDuck
       short
     end
 
+    # Generates member :id from member hash
+    def self.member_id(m)
+      # Sanitize $ in member names with something safer
+      name = m[:name].gsub(/\$/, 'S-')
+      "#{m[:meta][:static] ? 'static-' : ''}#{m[:tagname]}-#{name}"
+    end
+
     # Returns default hash that has empty array for each member type
     def self.default_members_hash
       return {
diff --git a/lib/jsduck/doc_formatter.rb b/lib/jsduck/doc_formatter.rb
index c95a2213448bc9fea4a013c602519af3c695acf8..7a759be2f2fe27e1fabc389164dd8c4fbba1f918 100644
--- a/lib/jsduck/doc_formatter.rb
+++ b/lib/jsduck/doc_formatter.rb
@@ -158,7 +158,7 @@ module JsDuck
           Logger.instance.warn(:link, "#{input} links to non-existing class", file, line)
           return text
         elsif member
-          ms = get_members(cls, member, type, static)
+          ms = find_members(cls, {:name => member, :tagname => type, :static => static})
           if ms.length == 0
             Logger.instance.warn(:link, "#{input} links to non-existing member", file, line)
             return text
@@ -171,7 +171,7 @@ module JsDuck
             # report ambiguity.
             instance_ms = ms.find_all {|m| !m[:meta][:static] }
             if instance_ms.length > 1
-              alternatives = instance_ms.map {|m| m[:tagname].to_s }.join(", ")
+              alternatives = instance_ms.map {|m| "#{m[:tagname]} in #{m[:owner]}" }.join(", ")
               Logger.instance.warn(:link_ambiguous, "#{input} is ambiguous: "+alternatives, file, line)
             elsif instance_ms.length == 0
               static_ms = ms.find_all {|m| m[:meta][:static] }
@@ -215,7 +215,7 @@ module JsDuck
 
     def replace_magic_link(cls, member)
       if cls && member
-        if @relations[cls] && get_matching_member(cls, member)
+        if @relations[cls] && get_matching_member(cls, {:name => member})
           return link(cls, member, cls+"."+member)
         else
           warn_magic_link("#{cls}##{member} links to non-existing " + (@relations[cls] ? "member" : "class"))
@@ -225,7 +225,7 @@ module JsDuck
           return link(cls, nil, cls)
         else
           cls2, member2 = split_to_cls_and_member(cls)
-          if @relations[cls2] && get_matching_member(cls2, member2)
+          if @relations[cls2] && get_matching_member(cls2, {:name => member2})
             return link(cls2, member2, cls2+"."+member2)
           elsif cls =~ /\.(js|css|html|php)\Z/
             # Ignore common filenames
@@ -234,7 +234,7 @@ module JsDuck
           end
         end
       elsif !cls && member
-        if get_matching_member(@class_context, member)
+        if get_matching_member(@class_context, {:name => member})
           return link(@class_context, member, member)
         elsif member =~ /\A([A-F0-9]{3}|[A-F0-9]{6})\Z/i || member =~ /\A[0-9]/
           # Ignore HEX color codes and
@@ -261,7 +261,7 @@ module JsDuck
       # Use the canonical class name for link (not some alternateClassName)
       cls = @relations[cls].full_name
       # prepend type name to member name
-      member = member && get_matching_member(cls, member, type, static)
+      member = member && get_matching_member(cls, {:name => member, :tagname => type, :static => static})
 
       @link_tpl.gsub(/(%[\w#-])/) do
         case $1
@@ -281,8 +281,8 @@ module JsDuck
       end
     end
 
-    def get_matching_member(cls, member, type=nil, static=nil)
-      ms = get_members(cls, member, type, static).find_all {|m| !m[:private] }
+    def get_matching_member(cls, query)
+      ms = find_members(cls, query).find_all {|m| !m[:private] }
       if ms.length > 1
         instance_ms = ms.find_all {|m| !m[:meta][:static] }
         instance_ms.length > 0 ? instance_ms[0] : ms.find_all {|m| m[:meta][:static] }[0]
@@ -291,8 +291,8 @@ module JsDuck
       end
     end
 
-    def get_members(cls, member, type=nil, static=nil)
-      @relations[cls] ? @relations[cls].get_members(member, type, static) : []
+    def find_members(cls, query)
+      @relations[cls] ? @relations[cls].find_members(query) : []
     end
 
     # Formats doc-comment for placement into HTML.
diff --git a/lib/jsduck/full_exporter.rb b/lib/jsduck/full_exporter.rb
index b646e1aa8dcbd8bf209467c9467bb7ad6aeea787..6e3f984d9da731a0035a674c415968e47007c6c1 100644
--- a/lib/jsduck/full_exporter.rb
+++ b/lib/jsduck/full_exporter.rb
@@ -4,7 +4,7 @@ module JsDuck
 
   # Exporter for all the class docs.
   class FullExporter
-    def initialize(relations, opts)
+    def initialize(relations, opts={})
       @relations = relations
       # opts parameter is here just for compatibility with other exporters
     end
@@ -14,9 +14,9 @@ module JsDuck
       h = cls.to_hash
       h[:members] = {}
       h[:statics] = {}
-      Class.default_members_hash.each_key do |key|
-        h[:members][key] = cls.members(key)
-        h[:statics][key] = cls.members(key, :statics)
+      Class.default_members_hash.each_key do |tagname|
+        h[:members][tagname] = export_members(cls, {:tagname => tagname, :static => false})
+        h[:statics][tagname] = export_members(cls, {:tagname => tagname, :static => true})
       end
       h[:component] = cls.inherits_from?("Ext.Component")
       h[:superclasses] = cls.superclasses.collect {|c| c.full_name }
@@ -31,6 +31,25 @@ module JsDuck
       h
     end
 
+    private
+
+    # Looks up members, and sorts them so that constructor method is first
+    def export_members(cls, cfg)
+      ms = cls.find_members(cfg)
+      ms.sort! {|a,b| a[:name] <=> b[:name] }
+      cfg[:tagname] == :method ? constructor_first(ms) : ms
+    end
+
+    # If methods list contains constructor, move it into the beginning.
+    def constructor_first(ms)
+      constr = ms.find {|m| m[:name] == "constructor" }
+      if constr
+        ms.delete(constr)
+        ms.unshift(constr)
+      end
+      ms
+    end
+
   end
 
 end
diff --git a/lib/jsduck/inherit_doc.rb b/lib/jsduck/inherit_doc.rb
index 1119d74b8cdf8710cdbabdf808d060cc1a6fb66e..a041c1438a879cafda138270ca72b68d58d8fcc4 100644
--- a/lib/jsduck/inherit_doc.rb
+++ b/lib/jsduck/inherit_doc.rb
@@ -53,9 +53,8 @@ module JsDuck
       members.each do |m|
         m[:tagname] = :cfg
       end
-      # The members lookup table inside class is no more valid, so
-      # reset it.
-      cls.reset_members_lookup!
+      # Ask class to update its internal caches for these members
+      cls.update_members!(members)
     end
 
     # For auto-detected members/classes (which have @private == :inherit)
@@ -73,6 +72,7 @@ module JsDuck
     #
     # If the parent also has @inheritdoc, continues recursively.
     def find_parent(m)
+
       inherit = m[:inheritdoc] || {}
       if inherit[:cls]
         # @inheritdoc MyClass#member
@@ -118,7 +118,6 @@ module JsDuck
         end
       end
 
-      #pp parent[:doc]
       return parent[:inheritdoc] ? find_parent(parent) : parent
     end
 
@@ -132,8 +131,8 @@ module JsDuck
         # Auto-detected properties can override either a property or a
         # config. So look for both types.
         if tagname == :property
-          cfg = cls.get_members(name, :cfg, static || false)[0]
-          prop = cls.get_members(name, :property, static || false)[0]
+          cfg = cls.find_members(:name => name, :tagname => :cfg, :static => static || false)[0]
+          prop = cls.find_members(:name => name, :tagname => :property, :static => static || false)[0]
 
           if cfg && prop
             prop
@@ -148,10 +147,10 @@ module JsDuck
         else
           # Unless the auto-detected member is detected as static,
           # look only at instance members.
-          cls.get_members(name, tagname, static || false)[0]
+          cls.find_members(:name => name, :tagname => tagname, :static => static || false)[0]
         end
       else
-        cls.get_members(name, tagname, static)[0]
+        cls.find_members(:name => name, :tagname => tagname, :static => static)[0]
       end
     end
 
diff --git a/lib/jsduck/lint.rb b/lib/jsduck/lint.rb
index 55efde40bd44dd4fa74be9f5f0b8e47e21df5d7c..76de178f7a0cc7cbd42d5981d52fb26b129634f9 100644
--- a/lib/jsduck/lint.rb
+++ b/lib/jsduck/lint.rb
@@ -17,6 +17,7 @@ module JsDuck
       warn_optional_params
       warn_duplicate_params
       warn_duplicate_members
+      warn_singleton_statics
       warn_empty_enums
     end
 
@@ -95,6 +96,17 @@ module JsDuck
       end
     end
 
+    # Print warnings for static members in singleton classes
+    def warn_singleton_statics
+      @relations.each do |cls|
+        if cls[:singleton]
+          cls.find_members({:static => true}).each do |m|
+            warn(:sing_static, "Static members don't make sense in singleton class #{@doc[:name]}", m)
+          end
+        end
+      end
+    end
+
     # print warnings for enums with no values
     def warn_empty_enums
       @relations.each do |cls|
diff --git a/lib/jsduck/merger.rb b/lib/jsduck/merger.rb
index 9300324298626ec3bc5da64f827e06b3c1b23963..1006397ab23f73abcdb13adbdf2c38c8fe752314 100644
--- a/lib/jsduck/merger.rb
+++ b/lib/jsduck/merger.rb
@@ -80,7 +80,7 @@ module JsDuck
       end
 
       h[:name] = merge_name(docs, code)
-      h[:id] = create_member_id(h)
+      h[:id] = JsDuck::Class.member_id(h)
 
       # Copy private to meta
       h[:meta][:private] = h[:private] if h[:private]
@@ -95,12 +95,6 @@ module JsDuck
       h
     end
 
-    def create_member_id(m)
-      # Sanitize $ in member names with something safer
-      name = m[:name].gsub(/\$/, 'S-')
-      "#{m[:meta][:static] ? 'static-' : ''}#{m[:tagname]}-#{name}"
-    end
-
     # Given array of full alias names like "foo.bar", "foo.baz"
     # build hash like {"foo" => ["bar", "baz"]}
     def build_aliases_hash(aliases)
diff --git a/spec/aggregator_overrides_spec.rb b/spec/aggregator_overrides_spec.rb
index 39c48a73d275beaf515b23a225ef544a4b4c4f48..56b892d81be61bdc6daf7ccc474e12d8d2593f16 100644
--- a/spec/aggregator_overrides_spec.rb
+++ b/spec/aggregator_overrides_spec.rb
@@ -30,7 +30,7 @@ describe JsDuck::Aggregator do
         /** @class Child @extends Parent */
           /** @method foo */
       EOF
-      @method = @docs["Child"].members(:method)[0]
+      @method = @docs["Child"].find_members(:tagname => :method)[0]
     end
 
     it_should_behave_like "override"
@@ -46,7 +46,7 @@ describe JsDuck::Aggregator do
 
         /** @class Child @extends Parent @mixins Mixin */
       EOF
-      @method = @docs["Child"].members(:method)[0]
+      @method = @docs["Child"].find_members(:tagname => :method)[0]
     end
 
     it_should_behave_like "override"
@@ -67,10 +67,10 @@ describe JsDuck::Aggregator do
       EOF
       # Call #members on two child classes, this will init the
       # :overrides in Mixin class
-      @docs["Child1"].members(:method)
-      @docs["Child2"].members(:method)
+      @docs["Child1"].find_members(:tagname => :method)[0]
+      @docs["Child2"].find_members(:tagname => :method)[0]
 
-      @method = @docs["Mixin"].members(:method)[0]
+      @method = @docs["Mixin"].find_members(:tagname => :method)[0]
     end
 
     it "gets :override property listing multiple methods" do
diff --git a/spec/class_spec.rb b/spec/class_spec.rb
index 5447cc25dfdaf9a10ff2f22b433d6e1b6bf7de32..7d13f1ad6ced068dcc55b2e8c7af802160946e4e 100644
--- a/spec/class_spec.rb
+++ b/spec/class_spec.rb
@@ -6,9 +6,9 @@ describe JsDuck::Class do
     cfg[:members].each do |m|
       m[:tagname] = :property unless m[:tagname]
       m[:owner] = cfg[:name]
-      m[:id] = (m[:static] ? "static-" : "") + (m[:tagname] ? "#{m[:tagname]}-" : "property-") + m[:name]
       m[:meta] = {} unless m[:meta]
       m[:meta][:static] = true if m[:static]
+      m[:id] = JsDuck::Class.member_id(m)
     end
 
     JsDuck::Class.new(cfg)
@@ -249,193 +249,6 @@ describe JsDuck::Class do
     end
   end
 
-  describe "#members" do
-
-    before do
-      @classes = {}
-      @parent = JsDuck::Class.new({
-        :name => "ParentClass",
-        :members => [
-          {:tagname => :method, :name => "baz", :owner => "ParentClass"},
-          {:tagname => :method, :name => "foo", :owner => "ParentClass"},
-          {:tagname => :method, :name => "constructor", :owner => "ParentClass"},
-          {:tagname => :method, :name => "frank", :owner => "ParentClass", :private => true},
-          {:tagname => :method, :name => "zappa", :owner => "ParentClass", :private => false},
-          {:tagname => :method, :name => "parentA", :owner => "ParentClass",
-            :meta => {:static => true}},
-          {:tagname => :method, :name => "parentB", :owner => "ParentClass",
-            :inheritable => true, :meta => {:static => true}},
-        ]
-      });
-      @classes["ParentClass"] = @parent
-      @parent.relations = @classes
-
-      @mixin = JsDuck::Class.new({
-        :name => "MixinClass",
-        :members => [
-          {:tagname => :method, :name => "xxx", :owner => "MixinClass"},
-          {:tagname => :method, :name => "pri", :owner => "MixinClass", :private => true},
-          {:tagname => :method, :name => "mixinA", :owner => "MixinClass",
-            :meta => {:static => true}},
-          {:tagname => :method, :name => "mixinB", :owner => "MixinClass",
-            :inheritable => true, :meta => {:static => true}},
-        ]
-      });
-      @classes["MixinClass"] = @mixin
-      @mixin.relations = @classes
-
-      @child = JsDuck::Class.new({
-        :name => "ChildClass",
-        :extends => "ParentClass",
-        :mixins => ["MixinClass"],
-        :members => [
-          {:tagname => :method, :name => "foo", :owner => "ChildClass"},
-          {:tagname => :method, :name => "bar", :owner => "ChildClass"},
-          {:tagname => :method, :name => "zappa", :owner => "ChildClass", :private => true},
-          {:tagname => :method, :name => "childA", :owner => "ChildClass",
-            :meta => {:static => true}},
-          {:tagname => :method, :name => "childB", :owner => "ChildClass",
-            :inheritable => true, :meta => {:static => true}},
-        ]
-      });
-      @classes["ChildClass"] = @child
-      @child.relations = @classes
-
-      @singletonChild = JsDuck::Class.new({
-        :name => "Singleton",
-        :extends => "ParentClass",
-        :mixins => ["MixinClass"],
-        :singleton => true,
-        :members => [
-          {:tagname => :method, :name => "sing", :owner => "Singleton", :files => [{}]},
-          {:tagname => :method, :name => "singStat", :owner => "Singleton", :files => [{}],
-            :meta => {:static => true}},
-        ]
-      });
-      @classes["Singleton"] = @singletonChild
-      @singletonChild.relations = @classes
-    end
-
-    it "returns constructor as first method" do
-      @members = @child.members(:method)
-      @members.first[:name].should == "constructor"
-    end
-
-    def members_as_hash(cls, type, context=:members)
-      h = {}
-      cls.members(type, context).each {|m| h[m[:name]] = m }
-      h
-    end
-
-    describe "(:method)" do
-      before do
-        @members = members_as_hash(@child, :method)
-      end
-
-      it "returns all members in current class" do
-        @members.should have_key("foo")
-        @members.should have_key("bar")
-        @members.should have_key("zappa")
-      end
-
-      it "inherites members of parent class" do
-        @members.should have_key("baz")
-        @members.should have_key("foo")
-        @members.should have_key("frank")
-      end
-
-      it "inherites members of mixin classes" do
-        @members.should have_key("xxx")
-        @members.should have_key("pri")
-      end
-
-      it "keeps ownership of current class members" do
-        @members["bar"][:owner].should == "ChildClass"
-      end
-
-      it "keeps ownership of non-overridden parent class members" do
-        @members["baz"][:owner].should == "ParentClass"
-      end
-
-      it "overrides parent class members with the same name" do
-        @members["foo"][:owner].should == "ChildClass"
-      end
-
-      describe "singleton class" do
-        before do
-          @members = members_as_hash(@singletonChild, :method)
-        end
-
-        it "inherits all instance members from parent" do
-          @members.should have_key("baz")
-          @members.should have_key("foo")
-        end
-
-        it "inherits all instace members from mixins" do
-          @members.should have_key("xxx")
-        end
-
-        it "lists its instance members" do
-          @members.should have_key("sing")
-        end
-
-        it "lists its static members as if they were instance members" do
-          @members.should have_key("singStat")
-        end
-      end
-    end
-
-    describe "(:method, :statics)" do
-      before do
-        @members = members_as_hash(@child, :method, :statics)
-      end
-
-      it "returns normal statics in current class" do
-        @members.should have_key("childA")
-      end
-
-      it "returns inheritableStatics in current class" do
-        @members.should have_key("childB")
-      end
-
-      it "doesn't inherit normal statics from parent class" do
-        @members.should_not have_key("parentA")
-      end
-
-      it "inherits inheritableStatics from parent class" do
-        @members.should have_key("parentB")
-      end
-
-      it "doesn't inherit normal statics from mixins" do
-        @members.should_not have_key("mixinA")
-      end
-
-      it "inherits inheritableStatics from mixins" do
-        @members.should have_key("mixinB")
-      end
-
-      describe "singleton class" do
-        before do
-          @members = members_as_hash(@singletonChild, :method, :statics)
-        end
-
-        it "doesn't inherit any static members from parent" do
-          @members.should_not have_key("parentA")
-          @members.should_not have_key("parentB")
-        end
-
-        it "doesn't inherit any static members from mixins" do
-          @members.should_not have_key("mixinA")
-          @members.should_not have_key("mixinB")
-        end
-
-        it "doesn't list any of his own static members" do
-          @members.should_not have_key("singStat")
-        end
-      end
-    end
-  end
-
   describe "#inherits_from" do
 
     before do
diff --git a/spec/full_exporter_spec.rb b/spec/full_exporter_spec.rb
new file mode 100644
index 0000000000000000000000000000000000000000..9afa6d12b449fb850e5b21d83c352caf1dfb5297
--- /dev/null
+++ b/spec/full_exporter_spec.rb
@@ -0,0 +1,72 @@
+require "jsduck/full_exporter"
+require "jsduck/class"
+require "jsduck/relations"
+
+describe JsDuck::FullExporter do
+
+  def make_class(cfg)
+    cfg[:members].each do |m|
+      m[:tagname] = :property unless m[:tagname]
+      m[:owner] = cfg[:name]
+      m[:meta] = {} unless m[:meta]
+      m[:meta][:static] = true if m[:static]
+      m[:id] = JsDuck::Class.member_id(m)
+    end
+
+    JsDuck::Class.new(cfg)
+  end
+
+  describe "#export" do
+
+    let(:cls) do
+      make_class({
+        :name => "Foo",
+        :members => [
+          {:tagname => :cfg, :name => "foo"},
+          {:tagname => :cfg, :name => "bar"},
+          {:tagname => :cfg, :name => "zap"},
+          {:tagname => :cfg, :name => "baz"},
+          {:tagname => :method, :name => "addFoo"},
+          {:tagname => :method, :name => "addBaz"},
+          {:tagname => :method, :name => "constructor"},
+          {:tagname => :method, :name => "statGet", :static => true},
+          {:tagname => :event, :name => "beforebar"},
+        ],
+      })
+    end
+
+    let(:result) do
+      JsDuck::FullExporter.new(JsDuck::Relations.new([cls])).export(cls)
+    end
+
+    it "places configs into :members->:cfg" do
+      result[:members][:cfg].length.should == 4
+    end
+
+    it "places instance methods into :members->:method" do
+      result[:members][:method].length.should == 3
+    end
+
+    it "places static methods into :statics->:method" do
+      result[:statics][:method].length.should == 1
+    end
+
+    it "places events into :members->:event" do
+      result[:members][:event].length.should == 1
+    end
+
+    it "places nothing into :members->:property as there are no properties" do
+      result[:members][:property].length.should == 0
+    end
+
+    it "sorts configs alphabetically" do
+      result[:members][:cfg].map {|m| m[:name] }.should == ["bar", "baz", "foo", "zap"]
+    end
+
+    it "sorts constructor first when sorting methods" do
+      result[:members][:method].map {|m| m[:name] }.should == ["constructor", "addBaz", "addFoo"]
+    end
+
+  end
+
+end
diff --git a/spec/hide_spec.rb b/spec/hide_spec.rb
index cc0b21eb468b877195aacc05644ae4b0e9ec7d30..737e2c37f6facba6c1566bd2615f7ea20c0f3494 100644
--- a/spec/hide_spec.rb
+++ b/spec/hide_spec.rb
@@ -4,38 +4,50 @@ require "jsduck/class"
 
 describe JsDuck::Class do
 
-  def members_as_hash(cls, type, context=:members)
+  def make_class(cfg)
+    cfg[:members].each do |m|
+      m[:tagname] = :property unless m[:tagname]
+      m[:owner] = cfg[:name]
+      m[:meta] = {} unless m[:meta]
+      m[:meta][:static] = true if m[:static]
+      m[:id] = JsDuck::Class.member_id(m)
+    end
+
+    JsDuck::Class.new(cfg)
+  end
+
+  def members_as_hash(cls)
     h = {}
-    cls.members(type, context).each {|m| h[m[:name]] = m }
+    cls.find_members().each {|m| h[m[:name]] = m }
     h
   end
 
   before do
     @classes = {}
-    @parent = JsDuck::Class.new({
+    @parent = make_class({
         :name => "ParentClass",
         :members => [
-          {:tagname => :method, :name => "foo", :owner => "ParentClass"},
-          {:tagname => :method, :name => "bar", :owner => "ParentClass"},
-          {:tagname => :method, :name => "zappa", :owner => "ParentClass"},
+          {:name => "foo"},
+          {:name => "bar"},
+          {:name => "zappa"},
         ]
       });
     @classes["ParentClass"] = @parent
     @parent.relations = @classes
 
-    @child = JsDuck::Class.new({
+    @child = make_class({
         :name => "ChildClass",
         :extends => "ParentClass",
         :members => [
-          {:tagname => :method, :name => "bar", :owner => "ChildClass"},
-          {:tagname => :method, :name => "baz", :owner => "ChildClass"},
-          {:tagname => :method, :name => "zappa", :owner => "ChildClass", :meta => {:hide => true}},
+          {:name => "bar"},
+          {:name => "baz"},
+          {:name => "zappa", :meta => {:hide => true}},
         ]
       });
     @classes["ChildClass"] = @child
     @child.relations = @classes
 
-    @members = members_as_hash(@child, :method)
+    @members = members_as_hash(@child)
   end
 
   it "has member that's inherited from parent" do