Synchronize public and private repositories

Signed-off-by: Ramon Bertran Monfort <rbertra@us.ibm.com>

Author: rbertran

.travis.yml

@@ -77,6 +77,12 @@ jobs:
               - set -e
               - . ./dev_tools/ci/travis_prolog
               - ./dev_tools/ci/code_conventions_003_documentation.sh
+        - stage: tests
+          name: mypy
+          script:
+              - set -e
+              - . ./dev_tools/ci/travis_prolog
+              - ./dev_tools/ci/code_conventions_004_mypy.sh
         - stage: tests
           name: tools RISCV
           script:

dev_tools/ci/check_ci.sh

@@ -23,6 +23,7 @@ shellcheck -x -s sh ./*.sh dev_tools/*/*.sh ./targets/*/dev_tools/*/*.sh
 ./dev_tools/ci/code_conventions_001_pycodestyle.sh
 ./dev_tools/ci/code_conventions_002_pylint.sh
 ./dev_tools/ci/code_conventions_003_documentation.sh
+./dev_tools/ci/code_conventions_004_mypy.sh
 # Fast Functional Tests (run for branches and PR)
 ./dev_tools/ci/test_001_end2end_tools.sh
 ./dev_tools/ci/test_002_end2end_examples.sh

dev_tools/ci/code_conventions_004_mypy.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env sh
+# Copyright 2011-2021 IBM Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Microprobe CI support scripts
+#
+
+set -e # Finish right after a non-zero return command
+
+if [ "$WORKSPACE" = "" ]; then
+	WORKSPACE=$(pwd)
+    export WORKSPACE
+fi
+
+# shellcheck source=dev_tools/ci/environment.sh
+. "$WORKSPACE/dev_tools/ci/environment.sh"
+start_script "$0"
+
+echo "Running mypy version:"
+python "$(command -v mypy)" --version
+
+set +e
+# shellcheck disable=SC2046
+$NICE python "$(command -v mypy)" src/microprobe/code src/microprobe/target --ignore-missing-imports --install-types --non-interactive > "mypy$PYTHON_VERSION.out"
+error=$?
+set -e
+
+echo "Return code: $error"
+
+error=$(echo "obase=2;$error" | bc | /usr/bin/tail -c 3)
+if [ "$error" != "0" ]; then
+    echo "Errors found, check mypy$PYTHON_VERSION.out file and fix them"
+	exit_error "$0" "mypy$PYTHON_VERSION.out"
+fi
+
+# TODO: check other error codes to be more strict
+echo "No errors found!"
+exit_success "$0"
+
+# vim: set tabstop=4 softtabstop=4 shiftwidth=4 expandtab

src/microprobe/code/bbl.py

@@ -82,8 +82,8 @@ def __init__(self, size: int, instructions: List[Instruction] = []):
 
         self._instdic = {}
 
-        self._address = None
-        self._displacement = 0
+        self._address: Address | None = None
+        self._displacement: int | None = 0
 
         if MICROPROBE_RC["verbose"]:
             progress = Progress(size, "Initializing BBL:")
@@ -104,7 +104,12 @@ def __init__(self, size: int, instructions: List[Instruction] = []):
                     self._instrs[self._pointer] = instructions[idx]
                 else:
                     self._instrs[self._pointer] = Instruction()
-                self._instdic[self._instrs[self._pointer]] = self._pointer
+
+                # Type hinting needs some help here :)
+                instr_index: Instruction | None = self._instrs[self._pointer]
+                assert instr_index is not None
+
+                self._instdic[instr_index] = self._pointer
                 self._pointer += 10
                 if MICROPROBE_RC["verbose"]:
                     progress()
@@ -153,7 +158,7 @@ def size(self):
         """Size of the basic block, number of instructions (::class:`~.int`)"""
         return len(self.instrs)
 
-    def _index(self, instr: Instruction):
+    def _index(self, instr: Instruction | None):
         """Returns the index of the given instruction within the basic block.
 
         Returns the index of the given instruction within the basic block.
@@ -163,7 +168,10 @@ def _index(self, instr: Instruction):
         :type instr: :class:`~.Instruction`
 
         """
-        return self._instdic.get(instr, -1)
+        if instr is None:
+            return -1
+        else:
+            return self._instdic.get(instr, -1)
 
     def get_instruction_index(self, instr: Instruction):
         """Returns the index of the given instruction within the basic block.

src/microprobe/code/context.py

@@ -79,7 +79,7 @@ def __init__(self,
         self._symbolic = symbolic
         self._fabsolute = absolute
 
-        self._dat = None
+        self._dat: DynamicAddressTranslation | None = None
 
         if default_context is not None:
             self = default_context.copy()
@@ -167,7 +167,7 @@ def set_register_value(self, register: Register,
         # assert value in self._value_registers.keys()
         # assert self._register_values[register] == value
 
-    def get_closest_value(self, value: int | float | Address | str):
+    def get_closest_value(self, value):
         """Returns the closest value to the given value.
 
         Returns the closest value to the given value. If there are
@@ -179,7 +179,7 @@ def get_closest_value(self, value: int | float | Address | str):
 
         """
 
-        possible_regs: List[Tuple[Register, int | float | Address | str]] = []
+        possible_regs = []
 
         for reg, val in self._register_values.items():
 
@@ -224,7 +224,7 @@ def get_closest_address_value(self, address: Address):
 
         return None
 
-    def get_register_closest_value(self, value: int | float | str):
+    def get_register_closest_value(self, value):
         """Returns the register with the closest value to the given value.
 
         Returns the register with the closest value to the given value.
@@ -237,7 +237,7 @@ def get_register_closest_value(self, value: int | float | str):
 
         """
 
-        possible_regs: List[Tuple[Register, int | float | str]] = []
+        possible_regs = []
 
         for reg, reg_value in self._register_values.items():
 
@@ -248,6 +248,8 @@ def get_register_closest_value(self, value: int | float | str):
                 continue
 
             if isinstance(reg_value, str):
+                # Type hinting needs some help with this one :)
+                assert isinstance(value, str)
                 if reg_value.split("_")[1] != value.split(" ")[1]:
                     continue
 
@@ -310,7 +312,7 @@ def unset_registers(self, registers: List[Register]):
         for reg in registers:
             self.unset_register(reg)
 
-    def unset_register(self, register: Register):
+    def unset_register(self, register):
         """Remove the value from a register.
 
         :param register: Registers

src/microprobe/code/ins.py

@@ -21,7 +21,7 @@
 # Built-in modules
 import copy
 from itertools import product
-from typing import TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING, Callable, List
 
 # Third party modules
 import six
@@ -114,11 +114,11 @@ def instruction_from_definition(definition: MicroprobeInstructionDefinition,
 
 
 def instruction_set_def_properties(instr,
-                                   definition: MicroprobeInstructionDefinition,
+                                   definition,
                                    building_block=None,
-                                   target: Target | None = None,
+                                   target=None,
                                    allowed_registers=None,
-                                   fix_relative: bool = True,
+                                   fix_relative=True,
                                    label_displ=None):
     """
     Set instruction properties from an intruction definition.
@@ -168,7 +168,7 @@ def instruction_set_def_properties(instr,
     LOG.debug("Operands, not fixed: %s", operands)
     if len(operands) > 0:
 
-        fixed_operands = []
+        fixed_operands: List[Address | InstructionAddress] = []
         relocation_mode = False
         LOG.debug("Fixed operands: %s", fixed_operands)
 
@@ -298,13 +298,14 @@ def instruction_set_def_properties(instr,
         instr.add_decorator(decorator_key, decorator_value)
 
     for register_name in allowed_registers:
-        if register_name not in list(target.registers.keys()):
+        assert target is not None
+        if register_name not in list(target.isa.registers.keys()):
             raise MicroprobeCodeGenerationError(
                 "Unknown register '%s'. Known registers: %s" %
-                (register_name, list(target.registers.keys())))
+                (register_name, list(target.isa.registers.keys())))
 
-        if target.registers[register_name] in instr.sets() + instr.uses():
-            instr.add_allow_register(target.registers[register_name])
+        if target.isa.registers[register_name] in instr.sets() + instr.uses():
+            instr.add_allow_register(target.isa.registers[register_name])
 
     # TODO : NO NEED TO CHECK ANYTHING JUST REPRODUCING!
     # reserve implicit operands (if they are not already
@@ -373,7 +374,7 @@ def __init__(self, operand_descriptor: OperandDescriptor):
         self._operand_descriptor = operand_descriptor
         self._value = None
         self._set_function = None
-        self._unset_function = None
+        self._unset_function: Callable[[], None] | None = None
 
     @property
     def value(self):
@@ -613,7 +614,7 @@ def _compute_length(self):
 
         return length
 
-    def _compute_possible_lengths(self, context: Context):
+    def _compute_possible_lengths(self, context):
         """Compute the possible lengths that can be generated.
 
         Compute the possible lengths that can be generated from the context
@@ -1596,7 +1597,7 @@ def __init__(self):
         self._mem_operands = []
         self._operands = RejectingOrderedDict()
 
-    def set_arch_type(self, instrtype: InstructionType):
+    def set_arch_type(self, instrtype):
         """
 
         :param instrtype:
@@ -1956,7 +1957,7 @@ def allowed_regs(self):
         """List of allowed registers of the instructon. """
         return self._allowed_regs
 
-    def set_label(self, label: str):
+    def set_label(self, label: str | None):
         """
 
         :param label:

src/microprobe/driver/__init__.py

@@ -15,8 +15,10 @@
 
 """
 
+from typing import List
+
 # Constants
-__all__ = []
+__all__: List[str] = []
 
 # Functions
 

src/microprobe/driver/guided.py

@@ -15,8 +15,10 @@
 
 """
 
+from typing import List
+
 # Constants
-__all__ = []
+__all__: List[str] = []
 
 # Functions
 

src/microprobe/schemas/__init__.py

@@ -16,9 +16,10 @@
 <your module documentation here>.
 """
 
+from typing import List
 
 # Constants
-__all__ = []
+__all__: List[str] = []
 
 # Functions
 

src/microprobe/target/__init__.py

@@ -96,6 +96,9 @@ def import_definition(definition_tuple: str
     if isinstance(definition_tuple, str):
         definition_tuple = _parse_definition_tuple(definition_tuple)
 
+    # Type hinting needs some help here :)
+    assert not isinstance(definition_tuple, str)
+
     isa_def, uarch_def, env_def = definition_tuple
     isa = import_isa_definition(os.path.dirname(isa_def.filename))
     env = import_env_definition(env_def.filename,
@@ -349,10 +352,10 @@ def __init__(self,
         :return: Target instance
         :rtype: :class:`~.Target`
         """
-        self._uarch = None
-        self._env = None
+        self._uarch: Microarchitecture | None = None
+        self._env: Environment | None = None
         self._policies = None
-        self._wrapper = None
+        self._wrapper: Wrapper | None = None
 
         self.set_isa(isa)