--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Save and load `Model` from/to Neo4j base.
+#
+# Nit models are composed by MEntities.
+# This module creates NeoNode for each MEntity found in a `Model` and save them into Neo4j database.
+#
+# see `Neo4jClient`.
+#
+# NeoNodes can also be translated back to MEntities to rebuild a Nit `Model`.
+#
+# Structure of the nit `Model` in base:
+#
+# `MProject`
+#
+# * labels: `model_name`, `MEntity`, `MProject`
+# * `(:MProject)-[:ROOT]->(:MGroup)`
+#
+# `MGroup`
+#
+# * labels: `model_name`, `MEntity`, `MGroup`
+# * `(:MGroup)-[:PROJECT]->(:MProject)`
+# * `(:MGroup)-[:PARENT]->(:MGroup)`
+#
+# `MModule`
+#
+# * labels: `model_name`, `MEntity`, `MModule`
+# * `(:MModule)-[:IMPORTS]->(:MModule)`
+# * `(:MModule)-[:INTRODUCES]->(:MClass)`
+# * `(:MModule)-[:DEFINES]->(:MClassDef)`
+#
+# `MClass`
+#
+# * labels: `model_name`, `MEntity`, `MClass`
+# * `(:MClass)-[:CLASSTYPE]->(:MClassType)`
+#
+# `MClassDef`
+#
+# * labels: `model_name`, `MEntity`, `MClassDef`
+# * `(:MClassDef)-[:BOUNDTYPE]->(:MClassType)`
+# * `(:MClassDef)-[:MCLASS]->(:MClass)`
+# * `(:MClassDef)-[:INTRODUCES]->(:MProperty)`
+# * `(:MClassDef)-[:DECLARES]->(:MPropDef)`
+#
+# `MProperty`
+#
+# * labels: `model_name`, `MEntity`, `MProperty`
+# * `(:MProperty)-[:INTRO_CLASSDEF]->(:MClassDef)`
+#
+# MProperties can also have labels `MMethod`, `MAttribute`, `MVirtualTypeProp`.
+#
+# `MPropDef`
+#
+# * labels: `model_name`, `MEntity`, `MPropDef`
+# * `(:MPropDef)-[:DEFINES]->(:MProperty)`
+#
+# MPropdefs can also have labels `MMethodDef`, `MAttributeDef`, `MVirtualTypeDef`.
+#
+# `MMethodDef` are linked to a `MSignature`:
+#
+# * `(:MMethodDef)-[:SIGNATURE]->(:MSignature)`
+#
+# `MVirtualTypeDef` are linked to a `MType` (its `bound`):
+#
+# * `(:MVirtualTypeDef)-[:BOUND]->(:MType)`
+#
+# `MType`
+#
+# * labels: `model_name`, `MEntity`, `MType`
+#
+# MTypes can also have labels `MClassType`, `MGenericType`, `MNullableType`, `MVirtualType`
+# and `MSignature`.
+#
+# `MClassType` and `MGenericType` both point to a `MClass` and have type `arguments`:
+#
+# * `(:MClassType)-[:CLASS]->(:MClass)`
+# * `(:MClassType)-[:ARGUMENT]->(:MType)`
+#
+# `MVirtualType` points to its introducing `MProperty`:
+#
+# * `(:MVirtualType)-[:PROPERTY]->(:MVirtualTypeDef)`
+#
+# `MParameterType` points to its introducing `MClass`:
+#
+# * `(:MParameterType)-[:CLASS]->(:MClass)`
+#
+# `MNullableType` points to its non-nullable `MType`:
+#
+# * `(:MNullableType)-[:TYPE]->(:MType)`
+#
+# `MSignature` can have `parameters` and a `return_mtype`:
+#
+# * `(:MSignature)-[:PARAMETER]->(:MParameter)`
+# * `(:MSignature)-[:RETURNTYPE]->(:MType)`
+#
+# `MParameter`
+#
+# * labels: `model_name`, `MEntity`, `MParameter`
+# * `(:MParameter)-[:TYPE]->(:MType)`
+module neo
+
+import model
+import neo4j
+import toolcontext
+
+# Helper class that can save and load a `Model` into a Neo4j database.
+class NeoModel
+
+ # The model name.
+ #
+ # Because we use only one Neo4j instance to store all the models,
+ # we need to mark their appartenance to a particular model and avoid loading all models.
+ #
+ # The name is used as a Neo label on each created nodes and used to load nodes from base.
+ var model_name: String
+
+ # The toolcontext used to init the `NeoModel` tool.
+ var toolcontext: ToolContext
+
+ # The Neo4j `client` used to communicate with the Neo4j instance.
+ var client: Neo4jClient
+
+ # 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)
+
+ toolcontext.info("Build model...", 1)
+ nodes = client.nodes_with_labels([model_name, "MProject"])
+ for node in nodes do to_mproject(model, node)
+ nodes = client.nodes_with_labels([model_name, "MGroup"])
+ for node in nodes do to_mgroup(model, node)
+ nodes = client.nodes_with_labels([model_name, "MModule"])
+ for node in nodes do to_mmodule(model, node)
+ nodes = client.nodes_with_labels([model_name, "MClass"])
+ for node in nodes do to_mclass(model, node)
+ nodes = client.nodes_with_labels([model_name, "MClassDef"])
+ for node in nodes do to_mclassdef(model, node)
+ nodes = client.nodes_with_labels([model_name, "MProperty"])
+ for node in nodes do to_mproperty(model, node)
+ nodes = client.nodes_with_labels([model_name, "MPropDef"])
+ for node in nodes do to_mpropdef(model, node)
+ return model
+ end
+
+ # Save `model` in the base pointed by `client`.
+ fun save(model: Model) do
+ var nodes = collect_model_nodes(model)
+ toolcontext.info("Save {nodes.length} nodes...", 1)
+ push_all(nodes)
+ var edges = collect_model_edges(model)
+ toolcontext.info("Save {edges.length} edges...", 1)
+ push_all(edges)
+ end
+
+ # Save `neo_entities` in base using batch mode.
+ private fun push_all(neo_entities: Collection[NeoEntity]) do
+ var batch = new NeoBatch(client)
+ var len = neo_entities.length
+ var sum = 0
+ var i = 1
+ for nentity in neo_entities do
+ batch.save_entity(nentity)
+ 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 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
+
+ # Execute `batch` and check for errors.
+ #
+ # Abort if `batch.execute` returns errors.
+ private fun do_batch(batch: NeoBatch) do
+ var errors = batch.execute
+ if not errors.is_empty then
+ print errors
+ exit(1)
+ end
+ end
+
+ # Collect all nodes from the current `model`.
+ private fun collect_model_nodes(model: Model): Collection[NeoNode] do
+ for mproject in model.mprojects do
+ to_node(mproject)
+ for mgroup in mproject.mgroups do to_node(mgroup)
+ end
+ return nodes.values
+ end
+
+ # Collect all edges from the current `model`.
+ #
+ # Actually collect all out_edges from all nodes.
+ private fun collect_model_edges(model: Model): Collection[NeoEdge] do
+ var edges = new HashSet[NeoEdge]
+ for node in nodes.values do edges.add_all(node.out_edges)
+ return edges
+ end
+
+ # Mentities associated to nodes.
+ private var mentities = new HashMap[NeoNode, MEntity]
+
+ # Nodes associated with MEntities.
+ private var nodes = new HashMap[MEntity, NeoNode]
+
+ # Get the `NeoNode` associated with `mentity`.
+ # `mentities` are stored locally to avoid duplication.
+ fun to_node(mentity: MEntity): NeoNode do
+ if nodes.has_key(mentity) then return nodes[mentity]
+ if mentity isa MProject then return mproject_node(mentity)
+ if mentity isa MGroup then return mgroup_node(mentity)
+ if mentity isa MModule then return mmodule_node(mentity)
+ if mentity isa MClass then return mclass_node(mentity)
+ if mentity isa MClassDef then return mclassdef_node(mentity)
+ if mentity isa MProperty then return mproperty_node(mentity)
+ if mentity isa MPropDef then return mpropdef_node(mentity)
+ if mentity isa MType then return mtype_node(mentity)
+ if mentity isa MParameter then return mparameter_node(mentity)
+ abort
+ end
+
+ # Make a new `NeoNode` based on `mentity`.
+ private fun make_node(mentity: MEntity): NeoNode do
+ var node = new NeoNode
+ nodes[mentity] = node
+ 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)
+ return node
+ end
+
+ # Build a `NeoNode` representing `mproject`.
+ private fun mproject_node(mproject: MProject): NeoNode do
+ var node = make_node(mproject)
+ node.labels.add "MProject"
+ var root = mproject.root
+ if root != null then
+ node.out_edges.add(new NeoEdge(node, "ROOT", to_node(root)))
+ end
+ return node
+ end
+
+ # Build a new `MProject` from a `node`.
+ #
+ # 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)
+ assert node.labels.has("MProject")
+ var mproject = new MProject(node["name"].to_s, model)
+ mentities[node] = mproject
+ set_doc(node, mproject)
+ mproject.root = to_mgroup(model, node.out_nodes("ROOT").first)
+ return mproject
+ end
+
+ # Build a `NeoNode` representing `mgroup`.
+ 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
+ node.out_edges.add(new NeoEdge(node, "PARENT", to_node(parent)))
+ end
+ for mmodule in mgroup.mmodules do
+ node.out_edges.add(new NeoEdge(node, "DECLARES", to_node(mmodule)))
+ end
+ for subgroup in mgroup.in_nesting.direct_smallers do
+ node.in_edges.add(new NeoEdge(node, "NESTS", to_node(subgroup)))
+ end
+ return node
+ end
+
+ # Build a new `MGroup` from a `node`.
+ #
+ # 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)
+ assert node.labels.has("MGroup")
+ var mproject = to_mproject(model, node.out_nodes("PROJECT").first)
+ var parent: nullable MGroup = null
+ var out = node.out_nodes("PARENT")
+ if not out.is_empty then
+ parent = to_mgroup(model, out.first)
+ end
+ var mgroup = new MGroup(node["name"].to_s, mproject, parent)
+ mentities[node] = mgroup
+ set_doc(node, mgroup)
+ return mgroup
+ end
+
+ # Build a `NeoNode` representing `mmodule`.
+ 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
+ for mclass in mmodule.intro_mclasses do
+ node.out_edges.add(new NeoEdge(node, "INTRODUCES", to_node(mclass)))
+ end
+ for mclassdef in mmodule.mclassdefs do
+ node.out_edges.add(new NeoEdge(node, "DEFINES", to_node(mclassdef)))
+ end
+ return node
+ end
+
+ # Build a new `MModule` from a `node`.
+ #
+ # 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)
+ assert node.labels.has("MModule")
+ var ins = node.in_nodes("DECLARES")
+ var mgroup: nullable MGroup = null
+ if not ins.is_empty then
+ mgroup = to_mgroup(model, ins.first)
+ end
+ 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
+ set_doc(node, mmodule)
+ var imported_mmodules = new Array[MModule]
+ for smod in node.out_nodes("IMPORTS") do
+ imported_mmodules.add to_mmodule(model, smod)
+ end
+ mmodule.set_imported_mmodules(imported_mmodules)
+ return mmodule
+ end
+
+ # Build a `NeoNode` representing `mclass`.
+ 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
+ node.out_edges.add(new NeoEdge(node, "CLASSTYPE", to_node(mclass.mclass_type)))
+ return node
+ end
+
+ # Build a new `MClass` from a `node`.
+ #
+ # 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)
+ 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
+ set_doc(node, mclass)
+ return mclass
+ end
+
+ # Build a `NeoNode` representing `mclassdef`.
+ 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
+ node.out_edges.add(new NeoEdge(node, "INTRODUCES", to_node(mproperty)))
+ end
+ for mpropdef in mclassdef.mpropdefs do
+ node.out_edges.add(new NeoEdge(node, "DECLARES", to_node(mpropdef)))
+ end
+ for sup in mclassdef.supertypes do
+ node.out_edges.add(new NeoEdge(node, "INHERITS", to_node(sup)))
+ end
+ return node
+ end
+
+ # Build a new `MClassDef` from a `node`.
+ #
+ # 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)
+ 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
+ set_doc(node, mclassdef)
+ var supertypes = new Array[MClassType]
+ for sup in node.out_nodes("INHERITS") do
+ supertypes.add to_mtype(model, sup).as(MClassType)
+ end
+ mclassdef.set_supertypes(supertypes)
+ mclassdef.add_in_hierarchy
+ return mclassdef
+ end
+
+ # Build a `NeoNode` representing `mproperty`.
+ 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["is_init"] = mproperty.is_init
+ else if mproperty isa MAttribute then
+ node.labels.add "MAttribute"
+ else if mproperty isa MVirtualTypeProp then
+ node.labels.add "MVirtualTypeProp"
+ end
+ node.out_edges.add(new NeoEdge(node, "INTRO_CLASSDEF", to_node(mproperty.intro_mclassdef)))
+ return node
+ end
+
+ # Build a new `MProperty` from a `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)
+ assert node.labels.has("MProperty")
+ var intro_mclassdef = to_mclassdef(model, node.out_nodes("INTRO_CLASSDEF").first)
+ var name = node["name"].to_s
+ var visibility = to_visibility(node["visibility"].to_s)
+ var mprop: nullable MProperty = null
+ if node.labels.has("MMethod") then
+ mprop = new MMethod(intro_mclassdef, name, visibility)
+ mprop.is_init = node["is_init"].as(Bool)
+ else if node.labels.has("MAttribute") then
+ mprop = new MAttribute(intro_mclassdef, name, visibility)
+ else if node.labels.has("MVirtualTypeProp") then
+ mprop = new MVirtualTypeProp(intro_mclassdef, name, visibility)
+ end
+ if mprop == null then
+ print "not yet implemented to_mproperty for {node.labels.join(",")}"
+ abort
+ end
+ mentities[node] = 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
+
+ # Build a `NeoNode` representing `mpropdef`.
+ 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
+ node.labels.add "MMethodDef"
+ node["is_abstract"] = mpropdef.is_abstract
+ node["is_intern"] = mpropdef.is_intern
+ node["is_extern"] = mpropdef.is_extern
+ var msignature = mpropdef.msignature
+ if msignature != null then
+ node.out_edges.add(new NeoEdge(node, "SIGNATURE", to_node(msignature)))
+ end
+ else if mpropdef isa MAttributeDef then
+ node.labels.add "MAttributeDef"
+ 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
+ end
+ return node
+ end
+
+ # Build a new `MPropDef` from a `node`.
+ #
+ # 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)
+ 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)
+ var location = to_location(node["location"].to_s)
+ var mpropdef: nullable MPropDef = null
+ if node.labels.has("MMethodDef") then
+ mpropdef = new MMethodDef(mclassdef, mproperty.as(MMethod), location)
+ 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
+ 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
+ else if node.labels.has("MVirtualTypeDef") then
+ mpropdef = new MVirtualTypeDef(mclassdef, mproperty.as(MVirtualTypeProp), location)
+ mentities[node] = mpropdef
+ var bound = node.out_nodes("BOUND")
+ if not bound.is_empty then mpropdef.bound = to_mtype(model, bound.first)
+ end
+ if mpropdef == null then
+ print "not yet implemented to_mpropdef for {node.labels.join(",")}"
+ abort
+ end
+ set_doc(node, mpropdef)
+ return mpropdef
+ end
+
+ # Build a `NeoNode` representing `mtype`.
+ private fun mtype_node(mtype: MType): NeoNode do
+ var node = make_node(mtype)
+ node.labels.add "MType"
+ if mtype isa MClassType then
+ node.labels.add "MClassType"
+ node.out_edges.add(new NeoEdge(node, "CLASS", to_node(mtype.mclass)))
+ for arg in mtype.arguments do
+ node.out_edges.add(new NeoEdge(node, "ARGUMENT", to_node(arg)))
+ end
+ if mtype isa MGenericType then
+ node.labels.add "MGenericType"
+ end
+ else if mtype isa MVirtualType then
+ node.labels.add "MVirtualType"
+ node.out_edges.add(new NeoEdge(node, "PROPERTY", to_node(mtype.mproperty)))
+ else if mtype isa MParameterType then
+ node.labels.add "MParameterType"
+ node["rank"] = mtype.rank
+ node.out_edges.add(new NeoEdge(node, "CLASS", to_node(mtype.mclass)))
+ else if mtype isa MNullableType then
+ node.labels.add "MNullableType"
+ node.out_edges.add(new NeoEdge(node, "TYPE", to_node(mtype.mtype)))
+ else if mtype isa MSignature then
+ node.labels.add "MSignature"
+ for mparameter in mtype.mparameters do
+ node.out_edges.add(new NeoEdge(node, "PARAMETER", to_node(mparameter)))
+ end
+ var return_mtype = mtype.return_mtype
+ if return_mtype != null then
+ node.out_edges.add(new NeoEdge(node, "RETURNTYPE", to_node(return_mtype)))
+ end
+ end
+ return node
+ end
+
+ # Build a new `MType` from a `node`.
+ #
+ # 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)
+ assert node.labels.has("MType")
+ if node.labels.has("MClassType") then
+ var mclass = to_mclass(model, node.out_nodes("CLASS").first)
+ var args = new Array[MType]
+ for narg in node.out_nodes("ARGUMENT") do
+ args.add to_mtype(model, narg)
+ end
+ var mtype = mclass.get_mtype(args)
+ mentities[node] = 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
+ 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
+ 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
+ return mtype
+ else if node.labels.has("MSignature") then
+ var mparameters = new Array[MParameter]
+ for pnode in node.out_nodes("PARAMETER") do
+ mparameters.add to_mparameter(model, pnode)
+ end
+ var return_mtype: nullable MType = null
+ var ret_nodes = node.out_nodes("RETURNTYPE")
+ if not ret_nodes.is_empty then
+ return_mtype = to_mtype(model, ret_nodes.first)
+ end
+ var mtype = new MSignature(mparameters, return_mtype)
+ mentities[node] = mtype
+ return mtype
+ end
+ print "not yet implemented to_mtype for {node.labels.join(",")}"
+ abort
+ end
+
+ # Build a `NeoNode` representing `mparameter`.
+ private fun mparameter_node(mparameter: MParameter): NeoNode do
+ var node = make_node(mparameter)
+ node.labels.add "MParameter"
+ node["name"] = mparameter.name
+ node["is_vararg"] = mparameter.is_vararg
+ node.out_edges.add(new NeoEdge(node, "TYPE", to_node(mparameter.mtype)))
+ return node
+ end
+
+ # Build a new `MParameter` from `node`.
+ #
+ # 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)
+ 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
+ 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)
+ end
+
+ # Get a `MVisibility` from its string representation.
+ private fun to_visibility(vis: String): MVisibility do
+ if vis == intrude_visibility.to_s then
+ return intrude_visibility
+ else if vis == public_visibility.to_s then
+ return public_visibility
+ else if vis == protected_visibility.to_s then
+ return protected_visibility
+ else if vis == private_visibility.to_s then
+ return private_visibility
+ else
+ return none_visibility
+ end
+ end
+
+ # Get a `MKind` from its string representation.
+ private fun to_kind(kind: String): MClassKind do
+ if kind == abstract_kind.to_s then
+ return abstract_kind
+ else if kind == concrete_kind.to_s then
+ return concrete_kind
+ else if kind == interface_kind.to_s then
+ return interface_kind
+ else if kind == enum_kind.to_s then
+ return enum_kind
+ else if kind == extern_kind.to_s then
+ return extern_kind
+ end
+ abort
+ end
+
+ # Extract the `MDoc` from `node` and link it to `mentity`.
+ private fun set_doc(node: NeoNode, mentity: MEntity) do
+ if node.has_key("mdoc") then
+ var lines = new Array[String]
+ for e in node["mdoc"].as(JsonArray) do
+ lines.add e.to_s#.replace("\n", "\\n")
+ end
+ var mdoc = new MDoc
+ mdoc.content.add_all(lines)
+ mdoc.original_mentity = mentity
+ mentity.mdoc = mdoc
+ end
+ end
+end
nitlanguage / nit.git / commitdiff