# See the License for the specific language governing permissions and
# limitations under the License.
-# Save and load `Model` from/to Neo4j base.
+# Save and load a `Model` to/from a Neo4j graph.
#
# Nit models are composed by MEntities.
-# This module creates NeoNode for each MEntity found in a `Model` and save them into Neo4j database.
+# This module creates NeoNode for each MEntity found in a `Model` and save them
+# into Neo4j database.
#
-# see `Neo4jClient`.
+# SEE: `Neo4jClient`
#
# NeoNodes can also be translated back to MEntities to rebuild a Nit `Model`.
#
-# Structure of the nit `Model` in base:
+# Structure of the nit `Model` in the graph:
+#
+# Note : Any null or empty attribute will not be saved in the database.
+#
+# For any `MEntity` (in addition to specific data):
+#
+# * labels: model name (`model_name`) and `MEntity`.
+# * `name`: short (unqualified) name.
+# * `mdoc`: JSON array representing the associated Markdown documentation
+# (one item by line).
+#
+# Note : All nodes described here are MEntities.
#
# `MProject`
#
-# * labels: `model_name`, `MEntity`, `MProject`
-# * `(:MProject)-[:ROOT]->(:MGroup)`
+# * labels: `MProject`, `model_name` and `MEntity`.
+# * `(:MProject)-[:ROOT]->(:MGroup)`: root of the group tree.
#
# `MGroup`
#
-# * labels: `model_name`, `MEntity`, `MGroup`
-# * `(:MGroup)-[:PROJECT]->(:MProject)`
-# * `(:MGroup)-[:PARENT]->(:MGroup)`
+# * labels: `MGroup`, `model_name` and `MEntity`.
+# * `(:MGroup)-[:PROJECT]->(:MProject)`: associated project.
+# * `(:MGroup)-[:PARENT]->(:MGroup)`: parent group. Does not exist for the root
+# group.
+# * `(:MGroup)-[:DECLARES]->(:MModule)`: modules that are direct children of
+# this group.
+# * `(:MGroup)-[:NESTS]->(:MGroup)`: nested groups that are direct children of
+# this group.
#
# `MModule`
#
-# * labels: `model_name`, `MEntity`, `MModule`
-# * `(:MModule)-[:IMPORTS]->(:MModule)`
-# * `(:MModule)-[:INTRODUCES]->(:MClass)`
-# * `(:MModule)-[:DEFINES]->(:MClassDef)`
+# * labels: `MModule`, `model_name` and `MEntity`.
+# * `location`: origin of the definition. SEE: `Location.to_s`
+# * `(:MModule)-[:IMPORTS]->(:MModule)`: modules that are imported directly.
+# * `(:MModule)-[:INTRODUCES]->(:MClass)`: all by classes introduced by this
+# module.
+# * `(:MModule)-[:DEFINES]->(:MClassDef)`: all class definitons contained in
+# this module.
#
# `MClass`
#
-# * labels: `model_name`, `MEntity`, `MClass`
-# * `(:MClass)-[:CLASSTYPE]->(:MClassType)`
+# * labels: `MClass`, `model_name` and `MEntity`.
+# * `kind`: kind of the class (`interface`, `abstract class`, etc.)
+# * `visibility`: visibility of the class.
+# * `parameter_names`: JSON array listing the name of each formal generic
+# parameter (in order of declaration).
+# * `(:MClass)-[:CLASSTYPE]->(:MClassType)`: SEE: `MClass.mclass_type`
+#
+# Arguments in the `CLASSTYPE` are named following the `parameter_names`
+# attribute of the `MClassDef` that introduces the class. A class definition
+# introduces a class if and only if it has this class as `MCLASS` and
+# has `is_intro` set to `true`.
#
# `MClassDef`
#
-# * labels: `model_name`, `MEntity`, `MClassDef`
-# * `(:MClassDef)-[:BOUNDTYPE]->(:MClassType)`
-# * `(:MClassDef)-[:MCLASS]->(:MClass)`
-# * `(:MClassDef)-[:INTRODUCES]->(:MProperty)`
-# * `(:MClassDef)-[:DECLARES]->(:MPropDef)`
+# * labels: `MClassDef`, `model_name` and `MEntity`.
+# * `location`: origin of the definition. SEE: `Location.to_s`
+# * `(:MClassDef)-[:BOUNDTYPE]->(:MClassType)`: bounded type associated to the
+# classdef.
+# * `(:MClassDef)-[:MCLASS]->(:MClass)`: associated `MClass`.
+# * `(:MClassDef)-[:INTRODUCES]->(:MProperty)`: all properties introduced by
+# the classdef.
+# * `(:MClassDef)-[:DECLARES]->(:MPropDef)`: all property definitions in the
+# classdef (introductions and redefinitions).
+# * `(:MClassDef)-[:INHERITS]->(:MClassType)`: all declared super-types
#
# `MProperty`
#
-# * labels: `model_name`, `MEntity`, `MProperty`
-# * `(:MProperty)-[:INTRO_CLASSDEF]->(:MClassDef)`
+# * labels: `MProperty`, `model_name` and `MEntity`. Must also have `MMethod`,
+# `MAttribute` `MVirtualTypeProp` or `MInnerClass`, depending on the class of
+# the represented entity.
+# * `visibility`: visibility of the property.
+# * `is_init`: Indicates if the property is a constructor. Exists only if the
+# node is a `MMethod`.
+# * `(:MProperty)-[:INTRO_CLASSDEF]->(:MClassDef)`: classdef that introduces
+# the property.
+#
+# Additional relationship for `MInnerClass`:
#
-# MProperties can also have labels `MMethod`, `MAttribute`, `MVirtualTypeProp`.
+# * `(:MInnerClassDef)-[:NESTS]->(:MClass)`: actual inner class.
#
# `MPropDef`
#
-# * labels: `model_name`, `MEntity`, `MPropDef`
-# * `(:MPropDef)-[:DEFINES]->(:MProperty)`
+# * labels: `MPropDef`, `model_name` and `MEntity`. Must also have `MMethodDef`,
+# `MAttributeDef`, `MVirtualTypeDef` or `MInnerClassDef`, depending on the
+# class of the represented entity.
+# * `location`: origin of the definition. SEE: `Location.to_s`.
+# * `(:MPropDef)-[:DEFINES]->(:MProperty)`: associated property.
+#
+# Additional attributes and relationship for `MMethodDef`:
#
-# MPropdefs can also have labels `MMethodDef`, `MAttributeDef`, `MVirtualTypeDef`.
+# * `is_abstract`: Is the method definition abstract?
+# * `is_intern`: Is the method definition intern?
+# * `is_extern`: Is the method definition extern?
+# * `(:MMethodDef)-[:SIGNATURE]->(:MSignature)`: signature attached to the
+# property definition.
#
-# `MMethodDef` are linked to a `MSignature`:
+# Additional relationship for `MAttributeDef`:
#
-# * `(:MMethodDef)-[:SIGNATURE]->(:MSignature)`
+# * `(:MAttributeDef)-[:TYPE]->(:MType)`: static type of the attribute,
+# if specified.
#
-# `MVirtualTypeDef` are linked to a `MType` (its `bound`):
+# Additional relationship for `MVirtualTypeDef`:
#
-# * `(:MVirtualTypeDef)-[:BOUND]->(:MType)`
+# * `(:MVirtualTypeDef)-[:BOUND]->(:MType)`: type to which the virtual type
+# is bound in this definition. Exists only if this definition bound the virtual
+# type to an effective type.
+#
+# Additional relationship for `MInnerClassDef`:
+#
+# * `(:MInnerClassDef)-[:NESTS]->(:MClassDef)`: actual inner class'
+# definition.
#
# `MType`
#
-# * labels: `model_name`, `MEntity`, `MType`
+# * labels: `MType`, `model_name` and `MEntity`. Must also have `MClassType`,
+# `MNullableType`, `MVirtualType`, `MRawType` or `MSignature`, depending on the
+# class of the represented entity.
+#
+# Additional label and relationships for `MClassType`:
+#
+# * If it is a `MGenericType`, also has the `MGenericType` label.
+# * `(:MClassType)-[:CLASS]->(:MClass)`: SEE: `MClassType.mclass`
+# * `(:MClassType)-[:ARGUMENT]->(:MType)`: type arguments.
+#
+# Arguments are named following the `parameter_names` attribute of the
+# `MClass` referred by `CLASS`.
+#
+# Additional relationship for `MVirtualType`:
#
-# MTypes can also have labels `MClassType`, `MGenericType`, `MNullableType`, `MVirtualType`
-# and `MSignature`.
+# * `(:MVirtualType)-[:PROPERTY]->(:MProperty)`: associated property that
+# determines the type (usually a `MVirtualTypeProp`).
#
-# `MClassType` and `MGenericType` both point to a `MClass` and have type `arguments`:
+# Additional attribute and relationship for `MParameterType`:
#
-# * `(:MClassType)-[:CLASS]->(:MClass)`
-# * `(:MClassType)-[:ARGUMENT]->(:MType)`
+# * `rank`: position of the parameter (0 for the first parameter).
+# * `(:MParameterType)-[:CLASS]->(:MClass)`: generic class where the parameter
+# belong.
#
-# `MVirtualType` points to its introducing `MProperty`:
+# Additional relationship for `MNullableType`:
#
-# * `(:MVirtualType)-[:PROPERTY]->(:MVirtualTypeDef)`
+# * `(:MNullableType)-[:TYPE]->(:MType)`: base type of the nullable type.
#
-# `MParameterType` points to its introducing `MClass`:
+# Additional attribute and relationship for `MRawType`:
#
-# * `(:MParameterType)-[:CLASS]->(:MClass)`
+# * `text`: JSON array of the parts’ text.
+# * `(:MRawType)-[:LINK]->(:MTypePart)`: the parts that link to another entity.
#
-# `MNullableType` points to its non-nullable `MType`:
+# Additional attribute and relationships for `MSignature`:
#
-# * `(:MNullableType)-[:TYPE]->(:MType)`
+# * `parameter_names`: JSON array representing the list of the parameter names.
+# * `(:MSignature)-[:PARAMETER]->(:MParameter)`: parameters.
+# * `(:MSignature)-[:RETURNTYPE]->(:MType)`: return type. Does not exist for
+# procedures.
#
-# `MSignature` can have `parameters` and a `return_mtype`:
+# In order to maintain the correct parameters order, each `MSignature` node
+# contains an array of parameter names corresponding to the parameter order in
+# the signature.
#
-# * `(:MSignature)-[:PARAMETER]->(:MParameter)`
-# * `(:MSignature)-[:RETURNTYPE]->(:MType)`
+# For example, if the source code contains:
+#
+# ~~~nitish
+# fun foo(a: A, b: B, c: C)
+# ~~~
+#
+# The `MSignature` node will contain a property
+# `parameter_names = ["a", "b", "c"]` so the MSignature can be reconstructed
+# with the parameters in the correct order.
#
# `MParameter`
#
-# * labels: `model_name`, `MEntity`, `MParameter`
-# * `(:MParameter)-[:TYPE]->(:MType)`
+# * labels: `MParameter`, `model_name` and `MEntity`.
+# * `is_vararg`: Is the parameter a vararg?
+# * `rank`: position of the parameter (0 for the first parameter).
+# * `(:MParameter)-[:TYPE]->(:MType)`: static type of the parameter.
+#
+# MParameters are also ranked by their position in the corresponding signature.
+# Rank 0 for the first parameter, 1 for the next one and etc.
+#
+# `MTypePart`
+#
+# * labels: `MTypePart`, `model_name` and `MEntity`.
+# * `rank`: position in the `MRawType`.
+# * `(:MTypePart)-[:TARGET]->(:MEntity)`: the target of the link.
module neo
-import model
+import doc::model_ext
import neo4j
import toolcontext
# Fill `model` using base pointed by `client`.
fun load(model: Model): Model do
- toolcontext.info("Locate all mentities...", 1)
- var nodes = client.nodes_with_label(model_name)
-
- toolcontext.info("Preload nodes...", 1)
- pull_all_nodes(nodes)
- toolcontext.info("Preload edges...", 1)
- pull_all_edges(nodes)
+ var nodes: Array[NeoNode]
- toolcontext.info("Build model...", 1)
+ toolcontext.info("Loading project node...", 1)
nodes = client.nodes_with_labels([model_name, "MProject"])
for node in nodes do to_mproject(model, node)
+ toolcontext.info("Loading groups...", 1)
nodes = client.nodes_with_labels([model_name, "MGroup"])
for node in nodes do to_mgroup(model, node)
+ toolcontext.info("Loading modules...", 1)
nodes = client.nodes_with_labels([model_name, "MModule"])
for node in nodes do to_mmodule(model, node)
+ toolcontext.info("Loading classes...", 1)
nodes = client.nodes_with_labels([model_name, "MClass"])
for node in nodes do to_mclass(model, node)
+ toolcontext.info("Loading class definitions...", 1)
nodes = client.nodes_with_labels([model_name, "MClassDef"])
for node in nodes do to_mclassdef(model, node)
+ toolcontext.info("Loading properties...", 1)
nodes = client.nodes_with_labels([model_name, "MProperty"])
for node in nodes do to_mproperty(model, node)
+ toolcontext.info("Loading property definitions...", 1)
nodes = client.nodes_with_labels([model_name, "MPropDef"])
for node in nodes do to_mpropdef(model, node)
return model
do_batch(batch)
end
- # Load content for all `nodes` from base.
- #
- # Content corresponds to properties and labels that are loaded in batch mode.
- private fun pull_all_nodes(nodes: Collection[NeoNode]) do
- var batch = new NeoBatch(client)
- var len = nodes.length
- var sum = 0
- var i = 1
- for node in nodes do
- batch.load_node(node)
- if i == batch_max_size then
- do_batch(batch)
- sum += batch_max_size
- toolcontext.info(" {sum * 100 / len}% done", 1)
- batch = new NeoBatch(client)
- i = 1
- else
- i += 1
- end
- end
- do_batch(batch)
- end
-
- # Load all edges from base linked to `nodes`.
- #
- # Edges are loaded in batch mode.
- private fun pull_all_edges(nodes: Collection[NeoNode]) do
- var batch = new NeoBatch(client)
- var len = nodes.length
- var sum = 0
- var i = 1
- for node in nodes do
- batch.load_node_edges(node)
- if i == batch_max_size then
- do_batch(batch)
- sum += batch_max_size
- toolcontext.info(" {sum * 100 / len}% done", 1)
- batch = new NeoBatch(client)
- i = 1
- else
- i += 1
- end
- end
- do_batch(batch)
- end
-
# How many operation can be executed in one batch?
private var batch_max_size = 1000
end
# Mentities associated to nodes.
- private var mentities = new HashMap[NeoNode, MEntity]
+ #
+ # The key is the node’s id.
+ private var mentities = new HashMap[Int, MEntity]
# Nodes associated with MEntities.
private var nodes = new HashMap[MEntity, NeoNode]
abort
end
+ # Get the `MEntity` associated with `node`.
+ fun to_mentity(model: Model, node: NeoNode): MEntity do
+ if node.labels.has("MProject") then return to_mproject(model, node)
+ if node.labels.has("MGroup") then return to_mgroup(model, node)
+ if node.labels.has("MModule") then return to_mmodule(model, node)
+ if node.labels.has("MClass") then return to_mclass(model, node)
+ if node.labels.has("MClassDef") then return to_mclassdef(model, node)
+ if node.labels.has("MProperty") then return to_mproperty(model, node)
+ if node.labels.has("MPropDef") then return to_mpropdef(model, node)
+ if node.labels.has("MType") then return to_mtype(model, node)
+ if node.labels.has("MParameter") then return to_mparameter(model, node)
+ abort
+ end
+
# Make a new `NeoNode` based on `mentity`.
private fun make_node(mentity: MEntity): NeoNode do
var node = new NeoNode
node.labels.add "MEntity"
node.labels.add model_name
node["name"] = mentity.name
- if mentity.mdoc != null then node["mdoc"] = new JsonArray.from(mentity.mdoc.content)
+ if mentity.mdoc != null then
+ node["mdoc"] = new JsonArray.from(mentity.mdoc.content)
+ node["mdoc_location"] = mentity.mdoc.location.to_s
+ end
return node
end
#
# REQUIRE `node.labels.has("MProject")`
private fun to_mproject(model: Model, node: NeoNode): MProject do
- if mentities.has_key(node) then return mentities[node].as(MProject)
+ var m = mentities.get_or_null(node.id.as(Int))
+ if m isa MProject then return m
+
assert node.labels.has("MProject")
var mproject = new MProject(node["name"].to_s, model)
- mentities[node] = mproject
+ mentities[node.id.as(Int)] = mproject
set_doc(node, mproject)
mproject.root = to_mgroup(model, node.out_nodes("ROOT").first)
return mproject
private fun mgroup_node(mgroup: MGroup): NeoNode do
var node = make_node(mgroup)
node.labels.add "MGroup"
- node["full_name"] = mgroup.full_name
var parent = mgroup.parent
node.out_edges.add(new NeoEdge(node, "PROJECT", to_node(mgroup.mproject)))
if parent != null then
#
# REQUIRE `node.labels.has("MGroup")`
private fun to_mgroup(model: Model, node: NeoNode): MGroup do
- if mentities.has_key(node) then return mentities[node].as(MGroup)
+ var m = mentities.get_or_null(node.id.as(Int))
+ if m isa MGroup then return m
+
assert node.labels.has("MGroup")
var mproject = to_mproject(model, node.out_nodes("PROJECT").first)
var parent: nullable MGroup = null
parent = to_mgroup(model, out.first)
end
var mgroup = new MGroup(node["name"].to_s, mproject, parent)
- mentities[node] = mgroup
+ mentities[node.id.as(Int)] = mgroup
set_doc(node, mgroup)
return mgroup
end
private fun mmodule_node(mmodule: MModule): NeoNode do
var node = make_node(mmodule)
node.labels.add "MModule"
- node["full_name"] = mmodule.full_name
node["location"] = mmodule.location.to_s
- var mgroup = mmodule.mgroup
for parent in mmodule.in_importation.direct_greaters do
node.out_edges.add(new NeoEdge(node, "IMPORTS", to_node(parent)))
end
#
# REQUIRE `node.labels.has("MModule")`
private fun to_mmodule(model: Model, node: NeoNode): MModule do
- if mentities.has_key(node) then return mentities[node].as(MModule)
+ var m = mentities.get_or_null(node.id.as(Int))
+ if m isa MModule then return m
+
assert node.labels.has("MModule")
var ins = node.in_nodes("DECLARES")
var mgroup: nullable MGroup = null
var name = node["name"].to_s
var location = to_location(node["location"].to_s)
var mmodule = new MModule(model, mgroup, name, location)
- mentities[node] = mmodule
+ mentities[node.id.as(Int)] = mmodule
set_doc(node, mmodule)
var imported_mmodules = new Array[MModule]
for smod in node.out_nodes("IMPORTS") do
private fun mclass_node(mclass: MClass): NeoNode do
var node = make_node(mclass)
node.labels.add "MClass"
- node["arity"] = mclass.arity
- node["full_name"] = mclass.full_name
node["kind"] = mclass.kind.to_s
node["visibility"] = mclass.visibility.to_s
+ if not mclass.mparameters.is_empty then
+ var parameter_names = new Array[String]
+ for p in mclass.mparameters do parameter_names.add(p.name)
+ node["parameter_names"] = new JsonArray.from(parameter_names)
+ end
node.out_edges.add(new NeoEdge(node, "CLASSTYPE", to_node(mclass.mclass_type)))
return node
end
#
# REQUIRE `node.labels.has("MClass")`
private fun to_mclass(model: Model, node: NeoNode): MClass do
- if mentities.has_key(node) then return mentities[node].as(MClass)
+ var m = mentities.get_or_null(node.id.as(Int))
+ if m isa MClass then return m
+
assert node.labels.has("MClass")
var mmodule = to_mmodule(model, node.in_nodes("INTRODUCES").first)
var name = node["name"].to_s
- var arity = node["arity"].to_s.to_i
var kind = to_kind(node["kind"].to_s)
var visibility = to_visibility(node["visibility"].to_s)
- var mclass = new MClass(mmodule, name, arity, kind, visibility)
- mentities[node] = mclass
+ var parameter_names = new Array[String]
+ if node.has_key("parameter_names") then
+ for e in node["parameter_names"].as(JsonArray) do
+ parameter_names.add e.to_s
+ end
+ end
+ var mclass = new MClass(mmodule, name, parameter_names, kind, visibility)
+ mentities[node.id.as(Int)] = mclass
set_doc(node, mclass)
return mclass
end
private fun mclassdef_node(mclassdef: MClassDef): NeoNode do
var node = make_node(mclassdef)
node.labels.add "MClassDef"
- node["is_intro"] = mclassdef.is_intro
node["location"] = mclassdef.location.to_s
- if not mclassdef.parameter_names.is_empty then
- node["parameter_names"] = new JsonArray.from(mclassdef.parameter_names)
- end
node.out_edges.add(new NeoEdge(node, "BOUNDTYPE", to_node(mclassdef.bound_mtype)))
node.out_edges.add(new NeoEdge(node, "MCLASS", to_node(mclassdef.mclass)))
for mproperty in mclassdef.intro_mproperties do
#
# REQUIRE `node.labels.has("MClassDef")`
private fun to_mclassdef(model: Model, node: NeoNode): MClassDef do
- if mentities.has_key(node) then return mentities[node].as(MClassDef)
+ var m = mentities.get_or_null(node.id.as(Int))
+ if m isa MClassDef then return m
+
assert node.labels.has("MClassDef")
var mmodule = to_mmodule(model, node.in_nodes("DEFINES").first)
var mtype = to_mtype(model, node.out_nodes("BOUNDTYPE").first).as(MClassType)
var location = to_location(node["location"].to_s)
- var parameter_names = new Array[String]
- if node.has_key("parameter_names") then
- for e in node["parameter_names"].as(JsonArray) do
- parameter_names.add e.to_s
- end
- end
- var mclassdef = new MClassDef(mmodule, mtype, location, parameter_names)
- mentities[node] = mclassdef
+ var mclassdef = new MClassDef(mmodule, mtype, location)
+ mentities[node.id.as(Int)] = mclassdef
set_doc(node, mclassdef)
var supertypes = new Array[MClassType]
for sup in node.out_nodes("INHERITS") do
private fun mproperty_node(mproperty: MProperty): NeoNode do
var node = make_node(mproperty)
node.labels.add "MProperty"
- node["full_name"] = mproperty.full_name
node["visibility"] = mproperty.visibility.to_s
if mproperty isa MMethod then
node.labels.add "MMethod"
node.labels.add "MAttribute"
else if mproperty isa MVirtualTypeProp then
node.labels.add "MVirtualTypeProp"
+ else if mproperty isa MInnerClass then
+ node.labels.add "MInnerClass"
+ node.out_edges.add(new NeoEdge(node, "NESTS", to_node(mproperty.inner)))
end
node.out_edges.add(new NeoEdge(node, "INTRO_CLASSDEF", to_node(mproperty.intro_mclassdef)))
return node
#
# REQUIRE `node.labels.has("MProperty")`
private fun to_mproperty(model: Model, node: NeoNode): MProperty do
- if mentities.has_key(node) then return mentities[node].as(MProperty)
+ var m = mentities.get_or_null(node.id.as(Int))
+ if m isa MProperty then return m
+
assert node.labels.has("MProperty")
var intro_mclassdef = to_mclassdef(model, node.out_nodes("INTRO_CLASSDEF").first)
var name = node["name"].to_s
mprop = new MAttribute(intro_mclassdef, name, visibility)
else if node.labels.has("MVirtualTypeProp") then
mprop = new MVirtualTypeProp(intro_mclassdef, name, visibility)
+ else if node.labels.has("MInnerClass") then
+ var inner = to_mclass(model, node.out_nodes("NESTS").first)
+ mprop = new MInnerClass(intro_mclassdef, name, visibility, inner)
end
if mprop == null then
print "not yet implemented to_mproperty for {node.labels.join(",")}"
abort
end
- mentities[node] = mprop
+ mentities[node.id.as(Int)] = mprop
set_doc(node, mprop)
- for npropdef in node.in_nodes("DEFINES") do
- var mpropdef = to_mpropdef(model, npropdef)
- if npropdef["is_intro"].as(Bool) then
- mprop.mpropdefs.unshift mpropdef
- else
- mprop.mpropdefs.add mpropdef
- end
- end
return mprop
end
private fun mpropdef_node(mpropdef: MPropDef): NeoNode do
var node = make_node(mpropdef)
node.labels.add "MPropDef"
- node["is_intro"] = mpropdef.is_intro
node["location"] = mpropdef.location.to_s
node.out_edges.add(new NeoEdge(node, "DEFINES", to_node(mpropdef.mproperty)))
if mpropdef isa MMethodDef then
end
else if mpropdef isa MAttributeDef then
node.labels.add "MAttributeDef"
+ var static_mtype = mpropdef.static_mtype
+ if static_mtype != null then
+ node.out_edges.add(new NeoEdge(node, "TYPE", to_node(static_mtype)))
+ end
else if mpropdef isa MVirtualTypeDef then
node.labels.add "MVirtualTypeDef"
var bound = mpropdef.bound
if bound != null then
node.out_edges.add(new NeoEdge(node, "BOUND", to_node(bound)))
end
+ else if mpropdef isa MInnerClassDef then
+ node.labels.add "MInnerClassDef"
+ node.out_edges.add(new NeoEdge(node, "NESTS", to_node(mpropdef.inner)))
end
return node
end
#
# REQUIRE `node.labels.has("MPropDef")`
private fun to_mpropdef(model: Model, node: NeoNode): MPropDef do
- if mentities.has_key(node) then return mentities[node].as(MPropDef)
+ var m = mentities.get_or_null(node.id.as(Int))
+ if m isa MPropDef then return m
+
assert node.labels.has("MPropDef")
var mclassdef = to_mclassdef(model, node.in_nodes("DECLARES").first)
var mproperty = to_mproperty(model, node.out_nodes("DEFINES").first)
mpropdef.is_abstract = node["is_abstract"].as(Bool)
mpropdef.is_intern = node["is_intern"].as(Bool)
mpropdef.is_extern = node["is_extern"].as(Bool)
- mentities[node] = mpropdef
+ mentities[node.id.as(Int)] = mpropdef
mpropdef.msignature = to_mtype(model, node.out_nodes("SIGNATURE").first).as(MSignature)
else if node.labels.has("MAttributeDef") then
mpropdef = new MAttributeDef(mclassdef, mproperty.as(MAttribute), location)
- mentities[node] = mpropdef
+ mentities[node.id.as(Int)] = mpropdef
+ var static_mtype = node.out_nodes("TYPE")
+ if not static_mtype.is_empty then mpropdef.static_mtype = to_mtype(model, static_mtype.first)
else if node.labels.has("MVirtualTypeDef") then
mpropdef = new MVirtualTypeDef(mclassdef, mproperty.as(MVirtualTypeProp), location)
- mentities[node] = mpropdef
+ mentities[node.id.as(Int)] = mpropdef
var bound = node.out_nodes("BOUND")
if not bound.is_empty then mpropdef.bound = to_mtype(model, bound.first)
+ else if node.labels.has("MInnerClassDef") then
+ var inner = to_mclassdef(model, node.out_nodes("NESTS").first)
+ mpropdef = new MInnerClassDef(mclassdef,
+ mproperty.as(MInnerClass), location, inner)
+ mentities[node.id.as(Int)] = mpropdef
end
if mpropdef == null then
print "not yet implemented to_mpropdef for {node.labels.join(",")}"
node.out_edges.add(new NeoEdge(node, "TYPE", to_node(mtype.mtype)))
else if mtype isa MSignature then
node.labels.add "MSignature"
+ var names = new JsonArray
+ var rank = 0
for mparameter in mtype.mparameters do
- node.out_edges.add(new NeoEdge(node, "PARAMETER", to_node(mparameter)))
+ names.add mparameter.name
+ var pnode = mparameter_node(mparameter)
+ pnode["rank"] = rank
+ node.out_edges.add(new NeoEdge(node, "PARAMETER", pnode))
+ rank += 1
end
+ if not names.is_empty then node["parameter_names"] = names
var return_mtype = mtype.return_mtype
if return_mtype != null then
node.out_edges.add(new NeoEdge(node, "RETURNTYPE", to_node(return_mtype)))
end
+ else if mtype isa MRawType then
+ node.labels.add "MRawType"
+ var text = new JsonArray
+ var rank = 0
+ for part in mtype.parts do
+ text.add part.text
+ if part.target != null then
+ var pnode = mtypepart_node(part)
+ pnode["rank"] = rank
+ node.out_edges.add(new NeoEdge(node, "LINK", pnode))
+ end
+ rank += 1
+ end
+ if not text.is_empty then node["text"] = text
+ end
+ return node
+ end
+
+ # Build a `NeoNode` representing `mtypepart`.
+ private fun mtypepart_node(mtypepart: MTypePart): NeoNode do
+ var node = make_node(mtypepart)
+ node.labels.add "MTypePart"
+ if mtypepart.target != null then
+ var target_node = to_node(mtypepart.target.as(not null))
+ node.out_edges.add(new NeoEdge(node, "TARGET", target_node))
end
return node
end
#
# REQUIRE `node.labels.has("MType")`
private fun to_mtype(model: Model, node: NeoNode): MType do
- if mentities.has_key(node) then return mentities[node].as(MType)
+ var m = mentities.get_or_null(node.id.as(Int))
+ if m isa MType then return m
+
assert node.labels.has("MType")
if node.labels.has("MClassType") then
var mclass = to_mclass(model, node.out_nodes("CLASS").first)
args.add to_mtype(model, narg)
end
var mtype = mclass.get_mtype(args)
- mentities[node] = mtype
+ mentities[node.id.as(Int)] = mtype
return mtype
else if node.labels.has("MParameterType") then
var mclass = to_mclass(model, node.out_nodes("CLASS").first)
var rank = node["rank"].to_s.to_i
- var mtype = new MParameterType(mclass, rank)
- mentities[node] = mtype
+ var mtype = mclass.mparameters[rank]
+ mentities[node.id.as(Int)] = mtype
return mtype
else if node.labels.has("MNullableType") then
var intype = to_mtype(model, node.out_nodes("TYPE").first)
- var mtype = new MNullableType(intype)
- mentities[node] = mtype
+ var mtype = intype.as_nullable
+ mentities[node.id.as(Int)] = mtype
return mtype
else if node.labels.has("MVirtualType") then
var mproperty = to_mproperty(model, node.out_nodes("PROPERTY").first)
- var mtype = new MVirtualType(mproperty)
- mentities[node] = mtype
+ assert mproperty isa MVirtualTypeProp
+ var mtype = mproperty.mvirtualtype
+ mentities[node.id.as(Int)] = mtype
return mtype
else if node.labels.has("MSignature") then
- var mparameters = new Array[MParameter]
+ # Get all param nodes
+ var mparam_nodes = new HashMap[String, MParameter]
for pnode in node.out_nodes("PARAMETER") do
- mparameters.add to_mparameter(model, pnode)
+ var mparam = to_mparameter(model, pnode)
+ mparam_nodes[mparam.name] = mparam
+ end
+ # Load params in the good order
+ var mparam_names = node["parameter_names"]
+ var mparameters = new Array[MParameter]
+ if mparam_names isa JsonArray then
+ for mparam_name in mparam_names do
+ var mparam = mparam_nodes[mparam_name.to_s]
+ mparameters.add mparam
+ end
end
var return_mtype: nullable MType = null
var ret_nodes = node.out_nodes("RETURNTYPE")
return_mtype = to_mtype(model, ret_nodes.first)
end
var mtype = new MSignature(mparameters, return_mtype)
- mentities[node] = mtype
+ mentities[node.id.as(Int)] = mtype
+ return mtype
+ else if node.labels.has("MRawType") then
+ var mtype = new MRawType(model)
+ var parts = node["text"]
+ if parts isa JsonArray then
+ for p in parts do
+ mtype.parts.add(new MTypePart(model, p.to_s, null))
+ end
+ for pnode in node.out_nodes("LINK") do
+ assert pnode.labels.has("MTypePart")
+ if not pnode.out_nodes("TARGET").is_empty then
+ var rank = pnode["rank"]
+ var target = to_mentity(model, pnode.out_nodes("TARGET").first)
+ assert rank isa Int
+ mtype.parts[rank] = mtype.parts[rank].link_to(target)
+ end
+ end
+ end
+ mentities[node.id.as(Int)] = mtype
return mtype
end
print "not yet implemented to_mtype for {node.labels.join(",")}"
node.labels.add "MParameter"
node["name"] = mparameter.name
node["is_vararg"] = mparameter.is_vararg
+ node["is_default"] = mparameter.is_default
node.out_edges.add(new NeoEdge(node, "TYPE", to_node(mparameter.mtype)))
return node
end
#
# REQUIRE `node.labels.has("MParameter")`
private fun to_mparameter(model: Model, node: NeoNode): MParameter do
- if mentities.has_key(node) then return mentities[node].as(MParameter)
+ var m = mentities.get_or_null(node.id.as(Int))
+ if m isa MParameter then return m
+
assert node.labels.has("MParameter")
var name = node["name"].to_s
var mtype = to_mtype(model, node.out_nodes("TYPE").first)
var is_vararg = node["is_vararg"].as(Bool)
- var mparameter = new MParameter(name, mtype, is_vararg)
- mentities[node] = mparameter
+ var is_default = node["is_default"].as(Bool)
+ var mparameter = new MParameter(name, mtype, is_vararg, is_default)
+ mentities[node.id.as(Int)] = mparameter
return mparameter
end
# Get a `Location` from its string representation.
private fun to_location(loc: String): Location do
- #TODO filepath
- var parts = loc.split_with(":")
- var file = new SourceFile.from_string(parts[0], "")
- var pos = parts[1].split_with("--")
- var pos1 = pos[0].split_with(",")
- var pos2 = pos[1].split_with(",")
- var line_s = pos1[0].to_i
- var line_e = pos2[0].to_i
- var column_s = pos1[1].to_i
- var column_e = 0
- if pos2.length == 2 then pos2[1].to_i
- return new Location(file, line_s, line_e, column_s, column_e)
+ return new Location.from_string(loc)
end
# Get a `MVisibility` from its string representation.
return protected_visibility
else if vis == private_visibility.to_s then
return private_visibility
+ else if vis == package_visibility.to_s then
+ return package_visibility
else
return none_visibility
end
return enum_kind
else if kind == extern_kind.to_s then
return extern_kind
+ else
+ return raw_kind(kind)
end
- abort
end
# Extract the `MDoc` from `node` and link it to `mentity`.
for e in node["mdoc"].as(JsonArray) do
lines.add e.to_s#.replace("\n", "\\n")
end
- var mdoc = new MDoc
+ var location = to_location(node["mdoc_location"].to_s)
+ var mdoc = new MDoc(location)
mdoc.content.add_all(lines)
mdoc.original_mentity = mentity
mentity.mdoc = mdoc
nitlanguage / nit.git / blobdiff