src/phase.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 # Phases of the processing of nit programs
  16 module phase
  17
  18 import toolcontext
  19 import parser
  20 import poset
  21
  22 redef class ToolContext
  23         # The various registered phases to performs
  24         # The order in the poset is the dependance of phases
  25         #
  26         # While you can directly modify the poset (nodes and edges),
  27         # it is often simpler to use the constructor in `Phase`
  28         var phases = new POSet[Phase]
  29
  30         fun phases_list: Sequence[Phase]
  31         do
  32                 var phases = self.phases.to_a
  33                 self.phases.sort(phases)
  34                 return phases
  35         end
  36
  37         # Run all registered phases on a set of modules
  38         fun run_phases(nmodules: Collection[AModule])
  39         do
  40                 var time0 = get_time
  41                 self.info("*** SEMANTIC ANALYSIS ***", 1)
  42                 #phases.show_dot
  43
  44                 var phases = phases_list
  45
  46                 for phase in phases do
  47                         self.info(" registered phases: {phase.class_name}", 2)
  48                 end
  49
  50                 for nmodule in nmodules do
  51                         self.info("Semantic analysis module {nmodule.location.file.filename}", 2)
  52                         for phase in phases do
  53                                 self.info(" phase: {phase.class_name}", 3)
  54                                 assert phase.toolcontext == self
  55                                 var errcount = self.error_count
  56                                 phase.process_nmodule(nmodule)
  57                                 if errcount != self.error_count then
  58                                         self.check_errors
  59                                         break
  60                                 end
  61                                 errcount = self.error_count
  62                                 for nclassdef in nmodule.n_classdefs do
  63                                         self.info(" phase: {phase.class_name} for {nclassdef.location}", 3)
  64                                         assert phase.toolcontext == self
  65                                         phase.process_nclassdef(nclassdef)
  66                                         for npropdef in nclassdef.n_propdefs do
  67                                                 self.info(" phase: {phase.class_name} for {npropdef.location}", 4)
  68                                                 assert phase.toolcontext == self
  69                                                 phase.process_npropdef(npropdef)
  70                                         end
  71                                 end
  72                                 if errcount != self.error_count then
  73                                         self.check_errors
  74                                         break
  75                                 end
  76                                 var v = new AnnotationPhaseVisitor(phase)
  77                                 v.enter_visit(nmodule)
  78                                 if errcount != self.error_count then
  79                                         self.check_errors
  80                                         break
  81                                 end
  82                         end
  83                         self.check_errors
  84                 end
  85
  86                 var time1 = get_time
  87                 self.info("*** END SEMANTIC ANALYSIS: {time1-time0} ***", 2)
  88         end
  89 end
  90
  91 private class AnnotationPhaseVisitor
  92         super Visitor
  93
  94         var phase: Phase
  95
  96         init(phase: Phase) do self.phase = phase
  97
  98         redef fun visit(n)
  99         do
 100                 n.visit_all(self)
 101                 if n isa AAnnotation then phase.process_annotated_node(n.parent.parent.as(not null), n)
 102         end
 103 end
 104
 105 # Abstraction of steps in the analysis/processing of Nit programs
 106 # Specific phases should implements one of the `process_*` method
 107 abstract class Phase
 108         # The toolcontext instance attached to the phase
 109         var toolcontext: ToolContext
 110
 111         # The dependence relation of the phase with the other phases
 112         var in_hierarchy: POSetElement[Phase]
 113
 114         # Initialize and register a phase to the toolcontext
 115         init(toolcontext: ToolContext, depends: nullable Collection[Phase])
 116         do
 117                 self.toolcontext = toolcontext
 118                 in_hierarchy = toolcontext.phases.add_node(self)
 119                 if depends != null then
 120                         for d in depends do
 121                                 toolcontext.phases.add_edge(self, d)
 122                         end
 123                 end
 124         end
 125
 126         # Specific actions to execute on the whole tree of a module
 127         # @toimplement
 128         fun process_nmodule(nmodule: AModule) do end
 129
 130         # Specific actions to execute on the tree of a class definition
 131         # Note that the order of the visit is the one of the file
 132         # @toimplement
 133         fun process_nclassdef(nclassdef: AClassdef) do end
 134
 135         # Specific actions to execute on the tree of a property
 136         # Note that the order of the visit is the one of the file
 137         # @toimplement
 138         fun process_npropdef(npropdef: APropdef) do end
 139
 140         # Specific actions to execute on annotated nodes
 141         # Note that the order of the visit is the one of the file
 142         # @toimplement
 143         fun process_annotated_node(node: ANode, nat: AAnnotation) do end
 144 end