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                                         for npropdef in nclassdef.n_propdefs do
  64                                                 assert phase.toolcontext == self
  65                                                 phase.process_npropdef(npropdef)
  66                                         end
  67                                 end
  68                                 if errcount != self.error_count then
  69                                         self.check_errors
  70                                         break
  71                                 end
  72                                 var v = new AnnotationPhaseVisitor(phase)
  73                                 v.enter_visit(nmodule)
  74                                 if errcount != self.error_count then
  75                                         self.check_errors
  76                                         break
  77                                 end
  78                         end
  79                         self.check_errors
  80                 end
  81
  82                 var time1 = get_time
  83                 self.info("*** END SEMANTIC ANALYSIS: {time1-time0} ***", 2)
  84         end
  85 end
  86
  87 private class AnnotationPhaseVisitor
  88         super Visitor
  89
  90         var phase: Phase
  91
  92         init(phase: Phase) do self.phase = phase
  93
  94         redef fun visit(n)
  95         do
  96                 n.visit_all(self)
  97                 if n isa AAnnotation then phase.process_annotated_node(n.parent.parent.as(not null), n)
  98         end
  99 end
 100
 101 # Abstraction of steps in the analysis/processing of Nit programs
 102 # Specific phases should implements one of the `process_*` method
 103 abstract class Phase
 104         # The toolcontext instance attached to the phase
 105         var toolcontext: ToolContext
 106
 107         # The dependence relation of the phase with the other phases
 108         var in_hierarchy: POSetElement[Phase]
 109
 110         # Initialize and register a phase to the toolcontext
 111         init(toolcontext: ToolContext, depends: nullable Collection[Phase])
 112         do
 113                 self.toolcontext = toolcontext
 114                 in_hierarchy = toolcontext.phases.add_node(self)
 115                 if depends != null then
 116                         for d in depends do
 117                                 toolcontext.phases.add_edge(self, d)
 118                         end
 119                 end
 120         end
 121
 122         # Specific actions to execute on the whole tree of a module
 123         # @toimplement
 124         fun process_nmodule(nmodule: AModule) do end
 125
 126         # Specific actions to execute on the tree of a property
 127         # Note that the order of the visit is the one of the file
 128         # @toimplement
 129         fun process_npropdef(npropdef: APropdef) do end
 130
 131         # Specific actions to execute on annotated nodes
 132         # Note that the order of the visit is the one of the file
 133         # @toimplement
 134         fun process_annotated_node(node: ANode, nat: AAnnotation) do end
 135 end