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