nitlanguage / nit.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
syntax: 'meth' -> 'fun', 'attr' -> 'var'
[nit.git] / src / nitdoc.nit
diff --git a/src/nitdoc.nit b/src/nitdoc.nit
index 2bfb3ad..5434df0 100644 (file)
--- a/src/nitdoc.nit
+++ b/src/nitdoc.nit
@@ -26,36 +26,37 @@ import abstracttool
 class DocContext
 special AbstractCompiler
        # Destination directory
 class DocContext
 special AbstractCompiler
        # Destination directory
-       readable writable attr _dir: String
+       readable writable var _dir: String = "."
 
        # Content of a generated file
 
        # Content of a generated file
-       attr _stage_context: StageContext = new StageContext(null)
+       var _stage_context: StageContext = new StageContext(null)
 
        # Add a string in the content
 
        # Add a string in the content
-       meth add(s: String) do
+       fun add(s: String) do
                _stage_context.content.add(s)
                _stage_context.validate = true
        end
 
        # Add a string in the content iff some other string are added
                _stage_context.content.add(s)
                _stage_context.validate = true
        end
 
        # Add a string in the content iff some other string are added
-       meth stage(s: String) do _stage_context.content.add(s)
+       fun stage(s: String) do _stage_context.content.add(s)
 
        # Create a new stage in the content
 
        # Create a new stage in the content
-       meth open_stage do _stage_context = new StageContext(_stage_context)
+       fun open_stage do _stage_context = new StageContext(_stage_context)
 
        # Close the current stage in the content
 
        # Close the current stage in the content
-       meth close_stage
+       fun close_stage
        do
                var s = _stage_context.parent
                if _stage_context.validate then
                        s.content.add_all(_stage_context.content)
                        s.validate = true
                end
        do
                var s = _stage_context.parent
                if _stage_context.validate then
                        s.content.add_all(_stage_context.content)
                        s.validate = true
                end
+               assert s != null
                _stage_context = s
        end
 
        # Write the content to a new file
                _stage_context = s
        end
 
        # Write the content to a new file
-       meth write_to(filename: String)
+       fun write_to(filename: String)
        do
                print "Generate {filename}"
                var f = new OFStream.open(filename)
        do
                print "Generate {filename}"
                var f = new OFStream.open(filename)
@@ -66,19 +67,19 @@ special AbstractCompiler
        end
 
        # Currently computed module
        end
 
        # Currently computed module
-       readable attr _module: MMSrcModule
+       readable var _module: nullable MMSrcModule
 
        # Is the current directory module computed as a simple modude ?
 
        # Is the current directory module computed as a simple modude ?
-       readable writable attr _inside_mode: Bool
+       readable writable var _inside_mode: Bool = false
 
        # Is the current module computed as a intruded one ?
 
        # Is the current module computed as a intruded one ?
-       readable writable attr _intrude_mode: Bool
+       readable writable var _intrude_mode: Bool = false
 
        # Compued introducing entities (for the index)
 
        # Compued introducing entities (for the index)
-       attr _entities: Array[MMEntity] = new Array[MMEntity]
+       var _entities: Array[MMEntity] = new Array[MMEntity]
 
        # Register an entity (for the index)
 
        # Register an entity (for the index)
-       meth register(e: MMEntity)
+       fun register(e: MMEntity)
        do
                _entities.add(e)
                if e isa MMSrcModule then
        do
                _entities.add(e)
                if e isa MMSrcModule then
@@ -87,13 +88,13 @@ special AbstractCompiler
        end
 
        # Start a new file
        end
 
        # Start a new file
-       meth clear
+       fun clear
        do
                _stage_context = new StageContext(null)
        end
 
        # Generate common files (frames, index, overview)
        do
                _stage_context = new StageContext(null)
        end
 
        # Generate common files (frames, index, overview)
-       meth extract_other_doc
+       fun extract_other_doc
        do
                _module = null
                inside_mode = false
        do
                _module = null
                inside_mode = false
@@ -179,7 +180,7 @@ special AbstractCompiler
                write_to("{dir}/index.html")
        end
 
                write_to("{dir}/index.html")
        end
 
-       meth add_header(title: String)
+       fun add_header(title: String)
        do
                add("<html><head><title>{title}</title></head>\n<body>\n")
                add("<table border=\"0\" width=\"100%\" cellpadding=\"1\" cellspacing=\"0\"><tr><td bgcolor=\"#eeeeff\">\n")
        do
                add("<html><head><title>{title}</title></head>\n<body>\n")
                add("<table border=\"0\" width=\"100%\" cellpadding=\"1\" cellspacing=\"0\"><tr><td bgcolor=\"#eeeeff\">\n")
@@ -207,20 +208,21 @@ special AbstractCompiler
        end
 
        # Sorter of entities in alphabetical order
        end
 
        # Sorter of entities in alphabetical order
-       attr _sorter: AlphaSorter[MMEntity] = new AlphaSorter[MMEntity]
+       var _sorter: AlphaSorter[MMEntity] = new AlphaSorter[MMEntity]
 
        # Sort entities in the alphabetical order
 
        # Sort entities in the alphabetical order
-       meth sort(array: Array[MMEntity])
+       fun sort(array: Array[MMEntity])
        do
                _sorter.sort(array)
        end
 
        do
                _sorter.sort(array)
        end
 
-       readable writable attr _owned_modules: Array[MMModule]
+       readable writable var _owned_modules: Array[MMModule] = new Array[MMModule]
 
        # Return the known_owner for current module
        # if inside_mode is set, it could be a different result
 
        # Return the known_owner for current module
        # if inside_mode is set, it could be a different result
-       meth known_owner_of(m: MMModule): MMModule
+       fun known_owner_of(m: MMModule): MMModule
        do
        do
+               var module = module
                if module == null then return m
                var res = module.known_owner_of(m)
                if not inside_mode and not intrude_mode and res.directory.owner == module then
                if module == null then return m
                var res = module.known_owner_of(m)
                if not inside_mode and not intrude_mode and res.directory.owner == module then
@@ -230,9 +232,9 @@ special AbstractCompiler
                end
        end
 
                end
        end
 
-       readable attr _opt_dir: OptionString = new OptionString("Directory where doc is generated", "-d", "--dir")
+       readable var _opt_dir: OptionString = new OptionString("Directory where doc is generated", "-d", "--dir")
 
 
-       redef meth perform_work(mods)
+       redef fun perform_work(mods)
        do
                dir.mkdir
 
        do
                dir.mkdir
 
@@ -243,39 +245,39 @@ special AbstractCompiler
                self.extract_other_doc
        end
 
                self.extract_other_doc
        end
 
-       redef init
+       init
        do
        do
-               super
+               super("nitdoc")
                option_context.add_option(opt_dir)
        end
 
                option_context.add_option(opt_dir)
        end
 
-       redef meth process_options
+       redef fun process_options
        do
                super
        do
                super
-               dir = opt_dir.value
-               if dir == null then dir = "."
+               var d = opt_dir.value
+               if d != null then dir = d
        end
 end
 
 # Conditionnal part of the text content of a DocContext
 class StageContext
        # Content of the current stage
        end
 end
 
 # Conditionnal part of the text content of a DocContext
 class StageContext
        # Content of the current stage
-       readable attr _content: Array[String] = new Array[String]
+       readable var _content: Array[String] = new Array[String]
 
        # Is a normal string already added?
 
        # Is a normal string already added?
-       readable writable attr _validate: Bool
+       readable writable var _validate: Bool = false
 
        # Parent stage is any
 
        # Parent stage is any
-       readable attr _parent: StageContext
+       readable var _parent: nullable StageContext = null
 
 
-       init(parent: StageContext) do _parent = parent
+       init(parent: nullable StageContext) do _parent = parent
 end
 
 
 # Efficiently sort object with their to_s method
 class AlphaSorter[E: Object]
 special AbstractSorter[E]
 end
 
 
 # Efficiently sort object with their to_s method
 class AlphaSorter[E: Object]
 special AbstractSorter[E]
-       redef meth compare(a, b)
+       redef fun compare(a, b)
        do
                var sa: String
                var sb: String
        do
                var sa: String
                var sb: String
@@ -296,7 +298,7 @@ special AbstractSorter[E]
        end
 
        # Keep track of to_s values
        end
 
        # Keep track of to_s values
-       attr _dico: HashMap[Object, String] = new HashMap[Object, String]
+       var _dico: HashMap[Object, String] = new HashMap[Object, String]
 
        init do end
 end
 
        init do end
 end
@@ -304,42 +306,42 @@ end
 # Generalization of metamodel entities
 class MMEntity
        # Return a link to
 # Generalization of metamodel entities
 class MMEntity
        # Return a link to
-       meth html_link(dctx: DocContext): String is abstract
+       fun html_link(dctx: DocContext): String is abstract
 
        # Is the entity should appear in the generaed doc
 
        # Is the entity should appear in the generaed doc
-       meth need_doc(dctx: DocContext): Bool is abstract
+       fun need_doc(dctx: DocContext): Bool is abstract
 
        # Return a one liner description
 
        # Return a one liner description
-       meth short_doc: String do return "&nbsp;"
+       fun short_doc: String do return "&nbsp;"
 
        # The doc node from the AST
        # Return null is none
 
        # The doc node from the AST
        # Return null is none
-       meth doc: ADoc do return null
+       fun doc: nullable ADoc do return null
 
        # Human redable location of the entity (module/class/property)
 
        # Human redable location of the entity (module/class/property)
-       meth locate(dctx: DocContext): String do return ""
+       fun locate(dctx: DocContext): String do return ""
 
        # Part of the prototype before the name (kind, modifiers, qualifier)
 
        # Part of the prototype before the name (kind, modifiers, qualifier)
-       meth prototype_head(dctx: DocContext): String is abstract
+       fun prototype_head(dctx: DocContext): String is abstract
 
        # Part of the property after the name (signature, modifiers)
 
        # Part of the property after the name (signature, modifiers)
-       meth prototype_body(dctx: DocContext): String do return ""
+       fun prototype_body(dctx: DocContext): String do return ""
 end
 
 redef class MMModule
 special MMEntity
 end
 
 redef class MMModule
 special MMEntity
-       redef meth html_link(dctx) do 
+       redef fun html_link(dctx) do 
                if dctx.module == self then 
                        return "{self}"
                else
                        return "<a href=\"{self}.html\">{self}</a>"
                end
        end
                if dctx.module == self then 
                        return "{self}"
                else
                        return "<a href=\"{self}.html\">{self}</a>"
                end
        end
-       redef meth need_doc(dctx) do return true
-       redef meth prototype_head(dctx) do return "module "
+       redef fun need_doc(dctx) do return true
+       redef fun prototype_head(dctx) do return "module "
 
 
-       attr _known_owner_of_cache: Map[MMModule, MMModule] = new HashMap[MMModule, MMModule]
-       meth known_owner_of(module: MMModule): MMModule
+       var _known_owner_of_cache: Map[MMModule, MMModule] = new HashMap[MMModule, MMModule]
+       fun known_owner_of(module: MMModule): MMModule
        do 
                if _known_owner_of_cache.has_key(module) then return _known_owner_of_cache[module]
                var res = module
        do 
                if _known_owner_of_cache.has_key(module) then return _known_owner_of_cache[module]
                var res = module
@@ -353,10 +355,10 @@ special MMEntity
        end
 
        # Return the most general module that own self
        end
 
        # Return the most general module that own self
-       meth owner(from: MMModule): MMModule
+       fun owner(from: MMModule): MMModule
        do
                var res = self
        do
                var res = self
-               var d = directory
+               var d: nullable MMDirectory = directory
                while d != null and d != from.directory do
                        var o = d.owner
                        if o != null and o.mhe <= res then res = o
                while d != null and d != from.directory do
                        var o = d.owner
                        if o != null and o.mhe <= res then res = o
@@ -365,7 +367,7 @@ special MMEntity
                return res
        end
 
                return res
        end
 
-       private meth known_owner_of_intern(module: MMModule, from: MMModule, as_owner: Bool): MMModule
+       private fun known_owner_of_intern(module: MMModule, from: MMModule, as_owner: Bool): MMModule
        do
                if module == self then return self
                var candidates = new Array[MMModule]
        do
                if module == self then return self
                var candidates = new Array[MMModule]
@@ -391,12 +393,12 @@ end
 redef class MMLocalProperty
 special MMEntity
        # Anchor of the property description in the module html file
 redef class MMLocalProperty
 special MMEntity
        # Anchor of the property description in the module html file
-       meth html_anchor: String
+       fun html_anchor: String
        do
                return "PROP_{local_class}_{cmangle(name)}"
        end
 
        do
                return "PROP_{local_class}_{cmangle(name)}"
        end
 
-       redef meth html_link(dctx)
+       redef fun html_link(dctx)
        do
                var m = module
                if not need_doc(dctx) then m = global.intro.module
        do
                var m = module
                if not need_doc(dctx) then m = global.intro.module
@@ -408,30 +410,24 @@ special MMEntity
                end
        end
        
                end
        end
        
-       redef meth short_doc do return concrete_property.short_doc
-
-       redef meth doc do return concrete_property.doc
-
-       redef meth need_doc(dctx) do return false
-
-       # Kind of property (meth, attr, etc.)
-       meth kind: String is abstract
+       # Kind of property (fun, attr, etc.)
+       fun kind: String is abstract
 
 
-       redef meth locate(dctx)
+       redef fun locate(dctx)
        do
                return "in {module.html_link(dctx)}::{local_class.html_link(dctx)}"
        end
 
        do
                return "in {module.html_link(dctx)}::{local_class.html_link(dctx)}"
        end
 
-       meth known_intro_class(dctx: DocContext): MMLocalClass
+       fun known_intro_class(dctx: DocContext): MMLocalClass
        do
                var mod = dctx.known_owner_of(global.intro.local_class.module)
                var cla = mod[global.intro.local_class.global]
                return cla
        end
 
        do
                var mod = dctx.known_owner_of(global.intro.local_class.module)
                var cla = mod[global.intro.local_class.global]
                return cla
        end
 
-       redef meth prototype_head(dctx)
+       redef fun prototype_head(dctx)
        do
        do
-               var res = ""
+               var res = new Buffer
                var intro_class = known_intro_class(dctx)
                var is_redef = local_class != intro_class
 
                var intro_class = known_intro_class(dctx)
                var is_redef = local_class != intro_class
 
@@ -450,36 +446,80 @@ special MMEntity
                                res.append(" {intro_class.module.html_link(dctx)}::")
                        end
                end
                                res.append(" {intro_class.module.html_link(dctx)}::")
                        end
                end
-               return res
+               return res.to_s
        end
 
        end
 
-       redef meth prototype_body(dctx)
+       redef fun prototype_body(dctx)
        do
        do
-               var res = signature.to_html(dctx)
+               var res = new Buffer
+               res.append(signature.to_html(dctx))
                var s = self
                var s = self
-               if s isa MMConcreteProperty then
+               if s.node != null then
                        if s.node isa ADeferredMethPropdef then
                                res.append(" is abstract")
                        else if s.node isa AInternMethPropdef then
                                res.append(" is intern")
                        end
                end
                        if s.node isa ADeferredMethPropdef then
                                res.append(" is abstract")
                        else if s.node isa AInternMethPropdef then
                                res.append(" is intern")
                        end
                end
-               return res
+               return res.to_s
+       end
+
+       redef fun need_doc(dctx)
+       do
+               if global.visibility_level >= 3 or self isa MMAttribute then
+                       if not dctx.intrude_mode then return false
+                       if dctx.module.visibility_for(module) == 0 then return false
+               end
+               if global.intro == self then
+                       return true
+               end
+               return doc != null
+       end
+
+       redef fun short_doc
+       do
+               var d = doc
+               if d != null then
+                       return d.short
+               else if global.intro == self then
+                       return "&nbsp;"
+               else
+                       return global.intro.short_doc
+               end
+       end
+       
+       redef fun doc
+       do
+               var n = node
+               if n == null or not node isa PPropdef then
+                       return null
+               end
+               assert n isa PPropdef
+               var d = n.n_doc
+               if d == null then
+                       return null
+               end
+               assert d isa ADoc
+               if d.n_comment.is_empty then
+                       return null
+               else
+                       return d
+               end
        end
 end
 redef class MMMethod
        end
 end
 redef class MMMethod
-       redef meth kind do return if global.is_init then "init" else "meth"
+       redef fun kind do return if global.is_init then "init" else "meth"
 end
 redef class MMAttribute
 end
 redef class MMAttribute
-       redef meth kind do return "attr"
+       redef fun kind do return "attr"
 end
 redef class MMTypeProperty
 end
 redef class MMTypeProperty
-       redef meth kind do return "type"
+       redef fun kind do return "type"
 end
 
 redef class MMSrcModule
        # Extract and generate html file for the module
 end
 
 redef class MMSrcModule
        # Extract and generate html file for the module
-       meth extract_module_doc(dctx: DocContext)
+       fun extract_module_doc(dctx: DocContext)
        do
                dctx.register(self)
 
        do
                dctx.register(self)
 
@@ -502,12 +542,12 @@ redef class MMSrcModule
                end
        end
 
                end
        end
 
-       meth extract_module_doc_inside(dctx: DocContext)
+       fun extract_module_doc_inside(dctx: DocContext)
        do
                dctx.add_header("Module {self}")
                dctx.add("<h1>Module {self}</h1>\n<dl>")
                var s = ""
        do
                dctx.add_header("Module {self}")
                dctx.add("<h1>Module {self}</h1>\n<dl>")
                var s = ""
-               var d = directory
+               var d: nullable MMDirectory = directory
                while d == null do
                        if d.owner != null and (d.owner != self or dctx.inside_mode or dctx.intrude_mode) then
                                s = "{d.owner.html_link(dctx)}::{s}"
                while d == null do
                        if d.owner != null and (d.owner != self or dctx.inside_mode or dctx.intrude_mode) then
                                s = "{d.owner.html_link(dctx)}::{s}"
@@ -520,8 +560,8 @@ redef class MMSrcModule
                var intrude_modules = new Array[MMModule]
                var public_modules = new Array[MMModule]
                var private_modules = new Array[MMModule]
                var intrude_modules = new Array[MMModule]
                var public_modules = new Array[MMModule]
                var private_modules = new Array[MMModule]
-               var owned_modules = new Array[MMModule]
-               dctx.owned_modules = owned_modules
+               var owned_modules = dctx.owned_modules
+               owned_modules.clear
                for m in mhe.greaters do
                        var v = visibility_for(m) 
                        if not dctx.inside_mode and not dctx.intrude_mode and m.directory.owner == self then 
                for m in mhe.greaters do
                        var v = visibility_for(m) 
                        if not dctx.inside_mode and not dctx.intrude_mode and m.directory.owner == self then 
@@ -567,10 +607,12 @@ redef class MMSrcModule
                                end
                        else
                                for m in owned_modules do
                                end
                        else
                                for m in owned_modules do
-                                       var mc = m[c.global]
-                                       if mc != null and mc.need_doc(dctx) then 
-                                               new_classes.add(c)
-                                               break
+                                       if m.global_classes.has(c.global) then
+                                               var mc = m[c.global]
+                                               if mc.need_doc(dctx) then
+                                                       new_classes.add(c)
+                                                       break
+                                               end
                                        end
                                end
                        end
                                        end
                                end
                        end
@@ -599,7 +641,7 @@ redef class MMSrcModule
                dctx.add("</body></html>\n")
        end
 
                dctx.add("</body></html>\n")
        end
 
-       redef meth short_doc
+       redef fun short_doc
        do
                var d = doc
                if d != null then
        do
                var d = doc
                if d != null then
@@ -609,23 +651,19 @@ redef class MMSrcModule
                end
        end
 
                end
        end
 
-       redef meth doc
+       redef fun doc
        do
                var n = node
        do
                var n = node
-               if not n isa AModule then
-                       return null
-               end
-               assert n isa AModule
                if n.n_packagedecl == null then
                        return null
                end
                var np = n.n_packagedecl
                assert np isa APackagedecl
                var d = np.n_doc
                if n.n_packagedecl == null then
                        return null
                end
                var np = n.n_packagedecl
                assert np isa APackagedecl
                var d = np.n_doc
-               assert d isa ADoc
                if d == null then
                        return null
                end
                if d == null then
                        return null
                end
+               assert d isa ADoc
                if d.n_comment.is_empty then
                        return null
                else
                if d.n_comment.is_empty then
                        return null
                else
@@ -636,17 +674,17 @@ end
 
 redef class ADoc
        # Html transcription of the doc
 
 redef class ADoc
        # Html transcription of the doc
-       meth to_html: String
+       fun to_html: String
        do
        do
-               var res = new String
+               var res = new Buffer
                for c in n_comment do
                        res.append(c.text.substring_from(1))
                end
                for c in n_comment do
                        res.append(c.text.substring_from(1))
                end
-               return res
+               return res.to_s
        end
 
        # Oneliner transcription of the doc
        end
 
        # Oneliner transcription of the doc
-       meth short: String
+       fun short: String
        do
                return n_comment.first.text.substring_from(1)
        end
        do
                return n_comment.first.text.substring_from(1)
        end
@@ -655,9 +693,9 @@ end
 redef class MMLocalClass
 special MMEntity
        # Anchor of the class description in the module html file
 redef class MMLocalClass
 special MMEntity
        # Anchor of the class description in the module html file
-       meth html_anchor: String do return "CLASS_{self}"
+       fun html_anchor: String do return "CLASS_{self}"
 
 
-       redef meth html_link(dctx)
+       redef fun html_link(dctx)
        do
                var m = module
                if not need_doc(dctx) then m = global.module
        do
                var m = module
                if not need_doc(dctx) then m = global.module
@@ -669,39 +707,41 @@ special MMEntity
                end
        end
 
                end
        end
 
-       redef meth short_doc do return global.intro.short_doc
+       redef fun short_doc do return global.intro.short_doc
 
 
-       redef meth doc do return global.intro.doc
+       redef fun doc do return global.intro.doc
 
 
-       redef meth need_doc(dctx) do
+       redef fun need_doc(dctx) do
                if module == dctx.module then
                        for m in dctx.owned_modules do
                if module == dctx.module then
                        for m in dctx.owned_modules do
-                               var c = m[global]
-                               if c != null and c.need_doc(dctx) then return true
+                               if m.global_classes.has(global) then
+                                       var c = m[global]
+                                       if c.need_doc(dctx) then return true
+                               end
                        end
                end
                return false
        end
 
                        end
                end
                return false
        end
 
-       redef meth locate(dctx) do return "in {module.html_link(dctx)}"
+       redef fun locate(dctx) do return "in {module.html_link(dctx)}"
 
 
-       meth known_intro(dctx: DocContext): MMLocalClass do return dctx.known_owner_of(global.intro.module)[global]
+       fun known_intro(dctx: DocContext): MMLocalClass do return dctx.known_owner_of(global.intro.module)[global]
 
 
-       redef meth prototype_head(dctx)
+       redef fun prototype_head(dctx)
        do
        do
-               var res = ""
+               var res = new Buffer
                var ki = known_intro(dctx)
                var is_redef = ki != self
                if is_redef then res.append("redef ")
                if global.visibility_level == 3 then res.append("private ")
                res.append("class ")
                if is_redef then res.append("{ki.module.html_link(dctx)}::")
                var ki = known_intro(dctx)
                var is_redef = ki != self
                if is_redef then res.append("redef ")
                if global.visibility_level == 3 then res.append("private ")
                res.append("class ")
                if is_redef then res.append("{ki.module.html_link(dctx)}::")
-               return res
+               return res.to_s
        end
 
        end
 
-       redef meth prototype_body(dctx)
+       redef fun prototype_body(dctx)
        do
        do
-               var res = ""
+               var res = new Buffer
                if arity > 0 then
                        res.append("[")
                        for i in [0..arity[ do
                if arity > 0 then
                        res.append("[")
                        for i in [0..arity[ do
@@ -712,11 +752,11 @@ special MMEntity
                        end
                        res.append("]")
                end
                        end
                        res.append("]")
                end
-               return res
+               return res.to_s
        end
 
        # Extract the doc of a class
        end
 
        # Extract the doc of a class
-       meth extract_class_doc(dctx: DocContext)
+       fun extract_class_doc(dctx: DocContext)
        do
                dctx.add("<a name=\"{html_anchor}\"></a><h2>{self}</h2><small>{module.html_link(dctx)}::</small><br/>{prototype_head(dctx)}<b>{self}</b>{prototype_body(dctx)}\n")
                dctx.add("<blockquote>\n")
        do
                dctx.add("<a name=\"{html_anchor}\"></a><h2>{self}</h2><small>{module.html_link(dctx)}::</small><br/>{prototype_head(dctx)}<b>{self}</b>{prototype_body(dctx)}\n")
                dctx.add("<blockquote>\n")
@@ -802,13 +842,13 @@ special MMEntity
                dctx.add("</blockquote><hr/>\n")
        end
 
                dctx.add("</blockquote><hr/>\n")
        end
 
-       meth pass_name(pass: Int): String
+       fun pass_name(pass: Int): String
        do
                var names = once ["Virtual Types", "Consructors", "Methods", "Attributes"]
                return names[pass]
        end
        
        do
                var names = once ["Virtual Types", "Consructors", "Methods", "Attributes"]
                return names[pass]
        end
        
-       meth accept_prop(p: MMLocalProperty, pass: Int): Bool
+       fun accept_prop(p: MMLocalProperty, pass: Int): Bool
        do
                if pass == 0 then
                        return p isa MMTypeProperty
        do
                if pass == 0 then
                        return p isa MMTypeProperty
@@ -822,25 +862,27 @@ special MMEntity
                abort
        end
 
                abort
        end
 
-       meth property_summary(dctx: DocContext, pass: Int): Array[MMLocalProperty]
+       fun property_summary(dctx: DocContext, pass: Int): Array[MMLocalProperty]
        do
                var passname = pass_name(pass)
                dctx.open_stage
                dctx.stage("<table border=\"1\" width=\"100%\" cellpadding=\"3\" cellspacing=\"0\">\n")
        do
                var passname = pass_name(pass)
                dctx.open_stage
                dctx.stage("<table border=\"1\" width=\"100%\" cellpadding=\"3\" cellspacing=\"0\">\n")
-               dctx.stage("<tr bgcolor=\"#CCCCFF\"><th colspan=\"2\">{passname} Summary of {self}</th><tr>\n")
+               dctx.stage("<tr bgcolor=\"#CCCCFF\"><th colspan=\"2\">{passname} Summary of {self}</th></tr>\n")
 
                var new_props = new Array[MMLocalProperty]
                for g in global_properties do
                        if not accept_prop(g.intro, pass) then continue
                        if module.visibility_for(g.intro.module) < g.visibility_level then continue
                        var p = self[g]
 
                var new_props = new Array[MMLocalProperty]
                for g in global_properties do
                        if not accept_prop(g.intro, pass) then continue
                        if module.visibility_for(g.intro.module) < g.visibility_level then continue
                        var p = self[g]
-                       if not p.need_doc(dctx) then
+                       if p.local_class != self or not p.need_doc(dctx) then
                                var cla = new Array[MMLocalClass]
                                for m in dctx.owned_modules do
                                var cla = new Array[MMLocalClass]
                                for m in dctx.owned_modules do
+                                       if not m.global_classes.has(global) then continue
                                        var c = m[global]
                                        var c = m[global]
-                                       if c == null or not c isa MMConcreteClass then continue
+                                       if not c isa MMConcreteClass then continue
+                                       if not c.has_global_property(g) then continue
                                        var p2 = c[g]
                                        var p2 = c[g]
-                                       if p2 == null or not p2.need_doc(dctx) then continue
+                                       if p2.local_class != c or not p2.need_doc(dctx) then continue
                                        cla.add(c)
                                end
                                if cla.is_empty then continue
                                        cla.add(c)
                                end
                                if cla.is_empty then continue
@@ -854,7 +896,7 @@ special MMEntity
                end
                dctx.sort(new_props)
                for p in new_props do
                end
                dctx.sort(new_props)
                for p in new_props do
-                       dctx.add("<tr><td width=\"20%\" align=\"right\">{p.prototype_head(dctx)}</td><td><b>{p.html_link(dctx)}</b>{p.prototype_body(dctx)}<br/>&nbsp;&nbsp;&nbsp;&nbsp;{p.short_doc}</td><tr>\n")
+                       dctx.add("<tr><td width=\"20%\" align=\"right\">{p.prototype_head(dctx)}</td><td><b>{p.html_link(dctx)}</b>{p.prototype_body(dctx)}<br/>&nbsp;&nbsp;&nbsp;&nbsp;{p.short_doc}</td></tr>\n")
                end
                dctx.stage("</table><br/>\n")
 
                end
                dctx.stage("</table><br/>\n")
 
@@ -869,7 +911,7 @@ special MMEntity
                                if c isa MMSrcLocalClass then
                                        var km = dctx.known_owner_of(c.module)
                                        var kc = km[c.global]
                                if c isa MMSrcLocalClass then
                                        var km = dctx.known_owner_of(c.module)
                                        var kc = km[c.global]
-                                       if kc == self or not c isa MMConcreteClass then continue
+                                       if kc == self then continue
                                        var props: Array[MMLocalProperty]
                                        if km == module then
                                                if cmap.has_key(kc) then
                                        var props: Array[MMLocalProperty]
                                        if km == module then
                                                if cmap.has_key(kc) then
@@ -888,7 +930,7 @@ special MMEntity
                                        end
                                        for g in c.global_properties do
                                                var p = c[g]
                                        end
                                        for g in c.global_properties do
                                                var p = c[g]
-                                               if p.need_doc(dctx) and accept_prop(p, pass) then
+                                               if p.local_class == c and p.need_doc(dctx) and accept_prop(p, pass) then
                                                        props.add(kc[g])
                                                end
                                        end
                                                        props.add(kc[g])
                                                end
                                        end
@@ -937,7 +979,7 @@ special MMEntity
                        end
                        for g in c.global_properties do
                                var p = c[g]
                        end
                        for g in c.global_properties do
                                var p = c[g]
-                               if p.need_doc(dctx) and accept_prop(p, pass) then
+                               if p.local_class == c and p.need_doc(dctx) and accept_prop(p, pass) then
                                        var kp = kc[g]
                                        if not props.has(kp) then props.add(kp)
                                end
                                        var kp = kc[g]
                                        if not props.has(kp) then props.add(kp)
                                end
@@ -964,7 +1006,7 @@ special MMEntity
                return new_props
        end
 
                return new_props
        end
 
-       meth property_detail(dctx: DocContext, pass: Int, new_props: Array[MMLocalProperty])
+       fun property_detail(dctx: DocContext, pass: Int, new_props: Array[MMLocalProperty])
        do
                var passname = pass_name(pass)
                dctx.open_stage
        do
                var passname = pass_name(pass)
                dctx.open_stage
@@ -992,12 +1034,12 @@ special MMEntity
        end
 
        # Add rows for properties inheriterd to some heirs
        end
 
        # Add rows for properties inheriterd to some heirs
-       meth properties_inherited_from(dctx: DocContext, heir: MMLocalClass, pass: Int)
+       fun properties_inherited_from(dctx: DocContext, heir: MMLocalClass, pass: Int)
        do
                var properties = new Array[String]
                for g in global_properties do
                        var p = self[g]
        do
                var properties = new Array[String]
                for g in global_properties do
                        var p = self[g]
-                       if p.need_doc(dctx) and accept_prop(p, pass) then
+                       if p.local_class == self and p.need_doc(dctx) and accept_prop(p, pass) then
                                properties.add(p.html_link(dctx))
                        end
                end
                                properties.add(p.html_link(dctx))
                        end
                end
@@ -1014,7 +1056,7 @@ special MMEntity
 end
 
 redef class MMSrcLocalClass
 end
 
 redef class MMSrcLocalClass
-       redef meth short_doc
+       redef fun short_doc
        do
                var d = doc
                if d != null then
        do
                var d = doc
                if d != null then
@@ -1027,7 +1069,7 @@ redef class MMSrcLocalClass
                end
        end
 
                end
        end
 
-       redef meth doc
+       redef fun doc
        do
                var n = nodes.first
                if not n isa AClassdef then
        do
                var n = nodes.first
                if not n isa AClassdef then
@@ -1035,10 +1077,10 @@ redef class MMSrcLocalClass
                end
                assert n isa AClassdef
                var d = n.n_doc
                end
                assert n isa AClassdef
                var d = n.n_doc
-               assert d isa ADoc
                if d == null then
                        return null
                end
                if d == null then
                        return null
                end
+               assert d isa ADoc
                if d.n_comment.is_empty then
                        return null
                else
                if d.n_comment.is_empty then
                        return null
                else
@@ -1046,7 +1088,7 @@ redef class MMSrcLocalClass
                end
        end
 
                end
        end
 
-       redef meth need_doc(dctx)
+       redef fun need_doc(dctx)
        do
                if global.visibility_level >= 3 then
                        if not dctx.intrude_mode then return false
        do
                if global.visibility_level >= 3 then
                        if not dctx.intrude_mode then return false
@@ -1064,56 +1106,11 @@ redef class MMSrcLocalClass
        end
 end
 
        end
 end
 
-redef class MMConcreteProperty
-       redef meth need_doc(dctx)
-       do
-               if global.visibility_level >= 3 or self isa MMAttribute then
-                       if not dctx.intrude_mode then return false
-                       if dctx.module.visibility_for(module) == 0 then return false
-               end
-               if global.intro == self then
-                       return true
-               end
-               return true
-       end
-
-       redef meth short_doc
-       do
-               var d = doc
-               if d != null then
-                       return d.short
-               else if global.intro == self then
-                       return "&nbsp;"
-               else
-                       return global.intro.short_doc
-               end
-       end
-       
-       redef meth doc
-       do
-               var n = node
-               if not node isa PPropdef then
-                       return null
-               end
-               assert n isa PPropdef
-               var d = n.n_doc
-               assert d isa ADoc
-               if d == null then
-                       return null
-               end
-               if d.n_comment.is_empty then
-                       return null
-               else
-                       return d
-               end
-       end
-end
-
 redef class MMSignature
        # Htlm transcription of the signature (with nested links)
 redef class MMSignature
        # Htlm transcription of the signature (with nested links)
-       meth to_html(dctx: DocContext): String
+       fun to_html(dctx: DocContext): String
        do
        do
-               var res = new String
+               var res = new Buffer
                if arity > 0 then
                        res.append("(")
                        res.append(self[0].html_link(dctx))
                if arity > 0 then
                        res.append("(")
                        res.append(self[0].html_link(dctx))
@@ -1127,23 +1124,24 @@ redef class MMSignature
                        res.append(": ")
                        res.append(return_type.html_link(dctx))
                end
                        res.append(": ")
                        res.append(return_type.html_link(dctx))
                end
-               return res
+               return res.to_s
        end
 end
 
 redef class MMType
        # Htlm transcription of the type (with nested links)
        end
 end
 
 redef class MMType
        # Htlm transcription of the type (with nested links)
-       meth html_link(dctx: DocContext): String do return to_s
+       fun html_link(dctx: DocContext): String do return to_s
 end
 
 redef class MMTypeSimpleClass
 end
 
 redef class MMTypeSimpleClass
-       redef meth html_link(dctx) do return local_class.html_link(dctx)
+       redef fun html_link(dctx) do return local_class.html_link(dctx)
 end
 
 redef class MMTypeGeneric
 end
 
 redef class MMTypeGeneric
-       redef meth html_link(dctx)
+       redef fun html_link(dctx)
        do
        do
-               var res = local_class.html_link(dctx)
+               var res = new Buffer
+               res.append(local_class.html_link(dctx))
                res.append("[")
                res.append(params[0].html_link(dctx))
                for i in [1..params.length[ do
                res.append("[")
                res.append(params[0].html_link(dctx))
                for i in [1..params.length[ do
@@ -1151,7 +1149,7 @@ redef class MMTypeGeneric
                        res.append(params[i].html_link(dctx))
                end
                res.append("]")
                        res.append(params[i].html_link(dctx))
                end
                res.append("]")
-               return res
+               return res.to_s
        end
 end
 
        end
 end
 
Nit language project; an oo programing language and its tool suite.