# by calling `ModelBuilder::android_project_for`.
module android_annotations
-import parser_util
-import modelbuilder
+private import parser_util
import modelize
import literal
import semantize
# Management and utilities on annotations
module annotation
-import parser
import modelbuilder
-import literal
+private import literal
import model::mmodule_data
redef class Prod
# print AST in an human form
module astprinter
-import phase
import semantize
intrude import parser
-import literal
+private import literal
private class ASTPrinterVisitor
super Visitor
# Check the consitency of AST
module astvalidation
-private import typing
intrude import parser
import astbuilder
module auto_super_init
import typing
-import modelbuilder
-import phase
+private import annotation
redef class ToolContext
var auto_super_init_phase: Phase = new AutoSuperInitPhase(self, [typing_phase])
# complex annotation that modify both the model and the AST of a Nit program
module cached
-import parser_util
import modelize
+private import parser_util
import simple_misc_analysis
private import annotation
module check_annotation
import phase
-import annotation
+private import annotation
redef class ToolContext
var check_annotation_phase: Phase = new CheckAnnotationPhase(self, null)
# to wrap foreign code in Nit methods.
module common_ffi
-import parser
import modelbuilder
import nitni
import c
private import annotation
+private import literal
redef class ToolContext
var pkgconfig_phase: Phase = new PkgconfigPhase(self, [literal_phase])
intrude import local_var_init
intrude import scope
intrude import toolcontext
+private import parser_util
redef class Model
# Cleans the model to remove a module and what it defines when semantic analysis fails on injected code
# This module is only an example of how to implements a simple phase in the nit tools
module div_by_zero
-import phase
import literal # Because we need the real value of literal in the AST
import semantize # Because we need the static type of receivers
# Intraprocedural static flow.
module flow
-import parser
-import toolcontext
import scope
-import phase
redef class ToolContext
var flow_phase: Phase = new FlowPhase(self, [scope_phase])
# Parsing of literal values in the abstract syntax tree.
module literal
-import parser
-import toolcontext
import phase
redef class ToolContext
# Require that the scope and the flow analaysis are already performed
module local_var_init
-import scope
import flow
-import phase
redef class ToolContext
var local_var_init_phase: Phase = new LocalVarInitPhase(self, [flow_phase])
private import parser
import html
private import highlight
+private import parser_util
# The class that does the convertion from a `ADoc` to HTML
private class Doc2Mdwn
# FIXME: better handling of the types
module model
-import poset
-import location
import mmodule
import mdoc
import ordered_tree
# FIXME add missing error checks
module modelbuilder
-import parser
import model
-import poset
-import opts
-import toolcontext
import phase
private import more_collections
module modelize_property
import modelize_class
-import annotation
+private import annotation
redef class ToolContext
var modelize_property_phase: Phase = new ModelizePropertyPhase(self, [modelize_class_phase])
module naive_interpreter
import literal
-import typing
-import auto_super_init
-import frontend
import common_ffi
+import semantize
private import parser::tables
redef class ToolContext
# to the target platform. Also detects conflicts between targetted platforms.
module platform
-import parser_util
-import modelbuilder
import modelize
+private import parser_util
private import annotation
redef class ToolContext
# It is quite efficient but the type set is global and pollutes each call site.
module rapid_type_analysis
-import model
-import modelbuilder
import semantize
-import csv # for live_types_to_csv
-import ordered_tree # for live_methods_to_tree
+private import csv # for live_types_to_csv
+private import ordered_tree # for live_methods_to_tree
private import more_collections
# Identification and scping of local variables and labels.
module scope
-import parser
-import toolcontext
import phase
redef class ToolContext
# Phase generating methods to serialize Nit objects to different formats
module serialization_phase
-import phase
-import parser_util
+private import parser_util
import modelize
+private import annotation
redef class ToolContext
var serialization_phase_pre_model: Phase = new SerializationPhasePreModel(self, null)
# * use of "while true" instead of "loop"
module simple_misc_analysis
-import toolcontext
-import parser
import phase
redef class ToolContext
# Base options for testing tools.
module testing_base
-import parser_util
import modelize
+private import parser_util
redef class ToolContext
# opt --full
import testing_base
import html
+private import annotation
redef class ToolContext
# -- target-file
module transform
import astbuilder
-import auto_super_init
import astvalidation
+import semantize
redef class ToolContext
var transform_phase: Phase = new TransformPhase(self, [typing_phase, auto_super_init_phase])
# By OO-services we mean message sending, attribute access, instantiation, etc.
module typing
-import flow
-import phase
import modelize
import local_var_init