From e04ebcf7575a24654dd757f1e4a6f6d3c03cc8b4 Mon Sep 17 00:00:00 2001
From: Jean Privat <jean@pryen.org>
Date: Sat, 21 Mar 2015 21:25:25 +0700
Subject: [PATCH] model: provide direct methods to access primitive types

This avoid that each module re-search class by their names

Signed-off-by: Jean Privat <jean@pryen.org>
---
 src/astbuilder.nit                         |    2 +-
 src/compiler/abstract_compiler.nit         |   12 ++++---
 src/compiler/global_compiler.nit           |    8 ++---
 src/compiler/separate_compiler.nit         |   22 +++++--------
 src/compiler/separate_erasure_compiler.nit |    2 +-
 src/interpreter/naive_interpreter.nit      |   40 +++++++----------------
 src/model/model.nit                        |   47 +++++++++++++++++-----------
 src/rapid_type_analysis.nit                |   19 +++++------
 src/transform.nit                          |    6 ----
 src/vm.nit                                 |    9 ------
 10 files changed, 68 insertions(+), 99 deletions(-)

diff --git a/src/astbuilder.nit b/src/astbuilder.nit
index 8aa0295..99c8763 100644
--- a/src/astbuilder.nit
+++ b/src/astbuilder.nit
@@ -32,7 +32,7 @@ class ASTBuilder
 	# Make a new Int literal
 	fun make_int(value: Int): AIntExpr
 	do
-		return new ADecIntExpr.make(value, mmodule.get_primitive_class("Int").mclass_type)
+		return new ADecIntExpr.make(value, mmodule.int_type)
 	end
 
 	# Make a new instatiation
diff --git a/src/compiler/abstract_compiler.nit b/src/compiler/abstract_compiler.nit
index aa57850..273ee6f 100644
--- a/src/compiler/abstract_compiler.nit
+++ b/src/compiler/abstract_compiler.nit
@@ -1078,9 +1078,6 @@ abstract class AbstractCompilerVisitor
 		self.writer = new CodeWriter(compiler.files.last)
 	end
 
-	# Force to get the primitive class named `name` or abort
-	fun get_class(name: String): MClass do return self.compiler.mainmodule.get_primitive_class(name)
-
 	# Force to get the primitive property named `name` in the instance `recv` or abort
 	fun get_property(name: String, recv: MType): MMethod
 	do
@@ -1416,6 +1413,11 @@ abstract class AbstractCompilerVisitor
 		end
 	end
 
+	# The currently processed module
+	#
+	# alias for `compiler.mainmodule`
+	fun mmodule: MModule do return compiler.mainmodule
+
 	# Generate an integer value
 	fun int_instance(value: Int): RuntimeVariable
 	do
@@ -1439,14 +1441,14 @@ abstract class AbstractCompilerVisitor
 	# Generate a string value
 	fun string_instance(string: String): RuntimeVariable
 	do
-		var mtype = self.get_class("String").mclass_type
+		var mtype = mmodule.string_type
 		var name = self.get_name("varonce")
 		self.add_decl("static {mtype.ctype} {name};")
 		var res = self.new_var(mtype)
 		self.add("if (likely({name}!=NULL)) \{")
 		self.add("{res} = {name};")
 		self.add("\} else \{")
-		var native_mtype = self.get_class("NativeString").mclass_type
+		var native_mtype = mmodule.native_string_type
 		var nat = self.new_var(native_mtype)
 		self.add("{nat} = \"{string.escape_to_c}\";")
 		var length = self.int_instance(string.length)
diff --git a/src/compiler/global_compiler.nit b/src/compiler/global_compiler.nit
index 7a0f162..53aef53 100644
--- a/src/compiler/global_compiler.nit
+++ b/src/compiler/global_compiler.nit
@@ -402,7 +402,7 @@ class GlobalCompilerVisitor
 
 	redef fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable
 	do
-		var ret_type = self.get_class("NativeArray").get_mtype([elttype])
+		var ret_type = mmodule.native_array_type(elttype)
 		ret_type = anchor(ret_type).as(MClassType)
 		return self.new_expr("NEW_{ret_type.c_name}({length})", ret_type)
 	end
@@ -894,10 +894,10 @@ class GlobalCompilerVisitor
 	redef fun array_instance(array, elttype)
 	do
 		elttype = self.anchor(elttype)
-		var arraytype = self.get_class("Array").get_mtype([elttype])
+		var arraytype = mmodule.array_type(elttype)
 		var res = self.init_instance(arraytype)
 		self.add("\{ /* {res} = array_instance Array[{elttype}] */")
-		var nat = self.new_var(self.get_class("NativeArray").get_mtype([elttype]))
+		var nat = self.new_var(mmodule.native_array_type(elttype))
 		nat.is_exact = true
 		self.add("{nat} = NEW_{nat.mtype.c_name}({array.length});")
 		for i in [0..array.length[ do
@@ -991,7 +991,7 @@ private class CustomizedRuntimeFunction
 		for i in [0..mmethoddef.msignature.arity[ do
 			var mtype = mmethoddef.msignature.mparameters[i].mtype
 			if i == mmethoddef.msignature.vararg_rank then
-				mtype = v.get_class("Array").get_mtype([mtype])
+				mtype = v.mmodule.array_type(mtype)
 			end
 			mtype = v.resolve_for(mtype, selfvar)
 			comment.append(", {mtype}")
diff --git a/src/compiler/separate_compiler.nit b/src/compiler/separate_compiler.nit
index f62d733..f94951e 100644
--- a/src/compiler/separate_compiler.nit
+++ b/src/compiler/separate_compiler.nit
@@ -268,7 +268,7 @@ class SeparateCompiler
 		if mclass.mclass_type.ctype_extern == "val*" then
 			return 0
 		else if mclass.kind == extern_kind and mclass.name != "NativeString" then
-			return self.box_kinds[self.mainmodule.get_primitive_class("Pointer")]
+			return self.box_kinds[self.mainmodule.pointer_type.mclass]
 		else
 			return self.box_kinds[mclass]
 		end
@@ -1967,8 +1967,8 @@ class SeparateCompilerVisitor
 
 	redef fun array_instance(array, elttype)
 	do
-		var nclass = self.get_class("NativeArray")
-		var arrayclass = self.get_class("Array")
+		var nclass = mmodule.native_array_class
+		var arrayclass = mmodule.array_class
 		var arraytype = arrayclass.get_mtype([elttype])
 		var res = self.init_instance(arraytype)
 		self.add("\{ /* {res} = array_instance Array[{elttype}] */")
@@ -1985,7 +1985,7 @@ class SeparateCompilerVisitor
 
 	redef fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable
 	do
-		var mtype = self.get_class("NativeArray").get_mtype([elttype])
+		var mtype = mmodule.native_array_type(elttype)
 		self.require_declaration("NEW_{mtype.mclass.c_name}")
 		assert mtype isa MGenericType
 		var compiler = self.compiler
@@ -2005,7 +2005,7 @@ class SeparateCompilerVisitor
 	redef fun native_array_def(pname, ret_type, arguments)
 	do
 		var elttype = arguments.first.mtype
-		var nclass = self.get_class("NativeArray")
+		var nclass = mmodule.native_array_class
 		var recv = "((struct instance_{nclass.c_name}*){arguments[0]})->values"
 		if pname == "[]" then
 			# Because the objects are boxed, return the box to avoid unnecessary (or broken) unboxing/reboxing
@@ -2026,14 +2026,6 @@ class SeparateCompilerVisitor
 		end
 	end
 
-	redef fun calloc_array(ret_type, arguments)
-	do
-		var mclass = self.get_class("ArrayCapable")
-		var ft = mclass.mparameters.first
-		var res = self.native_array_instance(ft, arguments[1])
-		self.ret(res)
-	end
-
 	fun link_unresolved_type(mclassdef: MClassDef, mtype: MType) do
 		assert mtype.need_anchor
 		var compiler = self.compiler
@@ -2144,7 +2136,7 @@ class SeparateRuntimeFunction
 		for i in [0..called_signature.arity[ do
 			var mtype = called_signature.mparameters[i].mtype
 			if i == called_signature.vararg_rank then
-				mtype = mmethoddef.mclassdef.mmodule.get_primitive_class("Array").get_mtype([mtype])
+				mtype = mmethoddef.mclassdef.mmodule.array_type(mtype)
 			end
 			sig.append(", {mtype.ctype} p{i}")
 		end
@@ -2183,7 +2175,7 @@ class SeparateRuntimeFunction
 		for i in [0..msignature.arity[ do
 			var mtype = msignature.mparameters[i].mtype
 			if i == msignature.vararg_rank then
-				mtype = v.get_class("Array").get_mtype([mtype])
+				mtype = v.mmodule.array_type(mtype)
 			end
 			comment.append(", {mtype}")
 			var argvar = new RuntimeVariable("p{i}", mtype, mtype)
diff --git a/src/compiler/separate_erasure_compiler.nit b/src/compiler/separate_erasure_compiler.nit
index 6e0d2b6..ada0bbf 100644
--- a/src/compiler/separate_erasure_compiler.nit
+++ b/src/compiler/separate_erasure_compiler.nit
@@ -643,7 +643,7 @@ class SeparateErasureCompilerVisitor
 
 	redef fun native_array_instance(elttype, length)
 	do
-		var nclass = self.get_class("NativeArray")
+		var nclass = mmodule.native_array_class
 		var mtype = nclass.get_mtype([elttype])
 		var res = self.new_var(mtype)
 		res.is_exact = true
diff --git a/src/interpreter/naive_interpreter.nit b/src/interpreter/naive_interpreter.nit
index 311d917..aba779a 100644
--- a/src/interpreter/naive_interpreter.nit
+++ b/src/interpreter/naive_interpreter.nit
@@ -201,8 +201,8 @@ class NaiveInterpreter
 	# Return the integer instance associated with `val`.
 	fun int_instance(val: Int): Instance
 	do
-		var ic = get_primitive_class("Int")
-		var instance = new PrimitiveInstance[Int](ic.mclass_type, val)
+		var t = mainmodule.int_type
+		var instance = new PrimitiveInstance[Int](t, val)
 		init_instance_primitive(instance)
 		return instance
 	end
@@ -210,8 +210,8 @@ class NaiveInterpreter
 	# Return the char instance associated with `val`.
 	fun char_instance(val: Char): Instance
 	do
-		var ic = get_primitive_class("Char")
-		var instance = new PrimitiveInstance[Char](ic.mclass_type, val)
+		var t = mainmodule.char_type
+		var instance = new PrimitiveInstance[Char](t, val)
 		init_instance_primitive(instance)
 		return instance
 	end
@@ -219,8 +219,8 @@ class NaiveInterpreter
 	# Return the float instance associated with `val`.
 	fun float_instance(val: Float): Instance
 	do
-		var ic = get_primitive_class("Float")
-		var instance = new PrimitiveInstance[Float](ic.mclass_type, val)
+		var t = mainmodule.float_type
+		var instance = new PrimitiveInstance[Float](t, val)
 		init_instance_primitive(instance)
 		return instance
 	end
@@ -239,9 +239,9 @@ class NaiveInterpreter
 	fun array_instance(values: Array[Instance], elttype: MType): Instance
 	do
 		assert not elttype.need_anchor
-		var nat = new PrimitiveInstance[Array[Instance]](get_primitive_class("NativeArray").get_mtype([elttype]), values)
+		var nat = new PrimitiveInstance[Array[Instance]](mainmodule.native_array_type(elttype), values)
 		init_instance_primitive(nat)
-		var mtype = get_primitive_class("Array").get_mtype([elttype])
+		var mtype = mainmodule.array_type(elttype)
 		var res = new MutableInstance(mtype)
 		self.init_instance(res)
 		self.send(self.force_get_primitive_method("with_native", mtype), [res, nat, self.int_instance(values.length)])
@@ -268,8 +268,8 @@ class NaiveInterpreter
 	do
 		var val = new FlatBuffer.from(txt)
 		val.add('\0')
-		var ic = get_primitive_class("NativeString")
-		var instance = new PrimitiveInstance[Buffer](ic.mclass_type, val)
+		var t = mainmodule.native_string_type
+		var instance = new PrimitiveInstance[Buffer](t, val)
 		init_instance_primitive(instance)
 		return instance
 	end
@@ -588,13 +588,6 @@ class NaiveInterpreter
 	# A hook to initialize a `PrimitiveInstance`
 	fun init_instance_primitive(recv: Instance) do end
 
-	# Return the primitive `MClass` corresponding to the `name` given in parameter
-	# `name` : name of the primitive class
-	fun get_primitive_class(name: String): MClass
-	do
-		return mainmodule.get_primitive_class(name)
-	end
-
 	# This function determines the correct type according to the receiver of the current propdef (self).
 	fun unanchor_type(mtype: MType): MType
 	do
@@ -1030,7 +1023,7 @@ redef class AMethPropdef
 			if pname == "files" then
 				var res = new Array[Instance]
 				for f in str.files do res.add v.string_instance(f)
-				return v.array_instance(res, v.get_primitive_class("String").mclass_type)
+				return v.array_instance(res, v.mainmodule.string_type)
 			end
 		else if pname == "calloc_string" then
 			return v.native_string_instance("!" * args[1].to_i)
@@ -1104,15 +1097,6 @@ redef class AMethPropdef
 			else if pname == "set_buffering_type" then
 				return v.int_instance(recvval.as(PrimitiveNativeFile).set_buffering_type(args[1].to_i, args[2].to_i))
 			end
-		else if pname == "calloc_array" then
-			var recvtype = args.first.mtype.as(MClassType)
-			var mtype: MType
-			mtype = recvtype.supertype_to(v.mainmodule, recvtype, v.get_primitive_class("ArrayCapable"))
-			mtype = mtype.arguments.first
-			var val = new Array[Instance].filled_with(v.null_instance, args[1].to_i)
-			var instance = new PrimitiveInstance[Array[Instance]](v.get_primitive_class("NativeArray").get_mtype([mtype]), val)
-			v.init_instance_primitive(instance)
-			return instance
 		else if pname == "native_argc" then
 			return v.int_instance(v.arguments.length)
 		else if pname == "native_argv" then
@@ -1606,7 +1590,7 @@ redef class ASuperstringExpr
 			if i == null then return null
 			array.add(i)
 		end
-		var i = v.array_instance(array, v.get_primitive_class("Object").mclass_type)
+		var i = v.array_instance(array, v.mainmodule.object_type)
 		var res = v.send(v.force_get_primitive_method("to_s", i.mtype), [i])
 		assert res != null
 		return res
diff --git a/src/model/model.nit b/src/model/model.nit
index b483543..3a64638 100644
--- a/src/model/model.nit
+++ b/src/model/model.nit
@@ -195,31 +195,40 @@ redef class MModule
 	private var flatten_mclass_hierarchy_cache: nullable POSet[MClass] = null
 
 	# The primitive type `Object`, the root of the class hierarchy
-	fun object_type: MClassType
-	do
-		var res = self.object_type_cache
-		if res != null then return res
-		res = self.get_primitive_class("Object").mclass_type
-		self.object_type_cache = res
-		return res
-	end
-
-	private var object_type_cache: nullable MClassType
+	var object_type: MClassType = self.get_primitive_class("Object").mclass_type is lazy
 
 	# The type `Pointer`, super class to all extern classes
 	var pointer_type: MClassType = self.get_primitive_class("Pointer").mclass_type is lazy
 
 	# The primitive type `Bool`
-	fun bool_type: MClassType
-	do
-		var res = self.bool_type_cache
-		if res != null then return res
-		res = self.get_primitive_class("Bool").mclass_type
-		self.bool_type_cache = res
-		return res
-	end
+	var bool_type: MClassType = self.get_primitive_class("Bool").mclass_type is lazy
+
+	# The primitive type `Int`
+	var int_type: MClassType = self.get_primitive_class("Int").mclass_type is lazy
+
+	# The primitive type `Char`
+	var char_type: MClassType = self.get_primitive_class("Char").mclass_type is lazy
+
+	# The primitive type `Float`
+	var float_type: MClassType = self.get_primitive_class("Float").mclass_type is lazy
+
+	# The primitive type `String`
+	var string_type: MClassType = self.get_primitive_class("String").mclass_type is lazy
+
+	# The primitive type `NativeString`
+	var native_string_type: MClassType = self.get_primitive_class("NativeString").mclass_type is lazy
+
+	# A primitive type of `Array`
+	fun array_type(elt_type: MType): MClassType do return array_class.get_mtype([elt_type])
+
+	# The primitive class `Array`
+	var array_class: MClass = self.get_primitive_class("Array") is lazy
+
+	# A primitive type of `NativeArray`
+	fun native_array_type(elt_type: MType): MClassType do return native_array_class.get_mtype([elt_type])
 
-	private var bool_type_cache: nullable MClassType
+	# The primitive class `NativeArray`
+	var native_array_class: MClass = self.get_primitive_class("NativeArray") is lazy
 
 	# The primitive type `Sys`, the main type of the program, if any
 	fun sys_type: nullable MClassType
diff --git a/src/rapid_type_analysis.nit b/src/rapid_type_analysis.nit
index a6cd32e..bcae37f 100644
--- a/src/rapid_type_analysis.nit
+++ b/src/rapid_type_analysis.nit
@@ -225,9 +225,9 @@ class RapidTypeAnalysis
 				var node = self.modelbuilder.mpropdef2node(mmethoddef)
 				var elttype = mmethoddef.msignature.mparameters[vararg_rank].mtype
 				#elttype = elttype.anchor_to(self.mainmodule, v.receiver)
-				var vararg = self.mainmodule.get_primitive_class("Array").get_mtype([elttype])
+				var vararg = self.mainmodule.array_type(elttype)
 				v.add_type(vararg)
-				var native = self.mainmodule.get_primitive_class("NativeArray").get_mtype([elttype])
+				var native = self.mainmodule.native_array_type(elttype)
 				v.add_type(native)
 				v.add_monomorphic_send(vararg, self.modelbuilder.force_get_primitive_method(node, "with_native", vararg.mclass, self.mainmodule))
 			end
@@ -471,11 +471,6 @@ class RapidTypeVisitor
 		return mtype
 	end
 
-	fun get_class(name: String): MClass
-	do
-		return analysis.mainmodule.get_primitive_class(name)
-	end
-
 	fun get_method(recv: MType, name: String): MMethod
 	do
 		var mtype = cleanup_type(recv)
@@ -540,7 +535,7 @@ redef class AArrayExpr
 	do
 		var mtype = self.mtype.as(MClassType)
 		v.add_type(mtype)
-		var native = v.analysis.mainmodule.get_primitive_class("NativeArray").get_mtype([mtype.arguments.first])
+		var native = v.analysis.mainmodule.native_array_type(mtype.arguments.first)
 		v.add_type(native)
 		mtype = v.cleanup_type(mtype).as(not null)
 		var prop = v.get_method(mtype, "with_native")
@@ -551,7 +546,7 @@ end
 redef class AStringFormExpr
 	redef fun accept_rapid_type_visitor(v)
 	do
-		var native = v.get_class("NativeString").mclass_type
+		var native = v.analysis.mainmodule.native_string_type
 		v.add_type(native)
 		var prop = v.get_method(native, "to_s_with_length")
 		v.add_monomorphic_send(native, prop)
@@ -561,9 +556,11 @@ end
 redef class ASuperstringExpr
 	redef fun accept_rapid_type_visitor(v)
 	do
-		var arraytype = v.get_class("Array").get_mtype([v.get_class("Object").mclass_type])
+		var mmodule = v.analysis.mainmodule
+		var object_type = mmodule.object_type
+		var arraytype = mmodule.array_type(object_type)
 		v.add_type(arraytype)
-		v.add_type(v.get_class("NativeArray").get_mtype([v.get_class("Object").mclass_type]))
+		v.add_type(mmodule.native_array_type(object_type))
 		var prop = v.get_method(arraytype, "join")
 		v.add_monomorphic_send(arraytype, prop)
 		var prop2 = v.get_method(arraytype, "with_native")
diff --git a/src/transform.nit b/src/transform.nit
index 8ae2c28..dac3c4f 100644
--- a/src/transform.nit
+++ b/src/transform.nit
@@ -73,12 +73,6 @@ private class TransformVisitor
 		node.full_transform_visitor(self)
 	end
 
-	# Get a primitive class or display a fatal error on `location`.
-	fun get_class(location: AExpr, name: String): MClass
-	do
-		return mmodule.get_primitive_class(name)
-	end
-
 	# Get a primitive method or display a fatal error on `location`.
 	fun get_method(location: AExpr, name: String, recv: MClass): MMethod
 	do
diff --git a/src/vm.nit b/src/vm.nit
index b253533..97069cf 100644
--- a/src/vm.nit
+++ b/src/vm.nit
@@ -177,15 +177,6 @@ class VirtualMachine super NaiveInterpreter
 		recv.vtable = recv.mtype.as(MClassType).mclass.vtable
 	end
 
-	# Create a virtual table for this `MClass` if not already done
-	redef fun get_primitive_class(name: String): MClass
-	do
-		var mclass = super
-
-		if not mclass.loaded then create_class(mclass)
-
-		return mclass
-	end
 
 	# Initialize the internal representation of an object (its attribute values)
 	# `init_instance` is the initial value of attributes
-- 
1.7.9.5