bug fix: track use of global variables

Author: fredokun

mrpython/typechecking/translate.py

@@ -98,7 +98,8 @@ def set_translator_locale(locale_key):
     , "Forbidden use of parameter '{}' as iteration variable" : { 'fr' : "Le paramètre de nom `{}` ne peut être utilisé comme variable d'itération" }
     , "Forbidden use of parameter '{}' as comprehension variable" : { 'fr' : "Le paramètre de nom `{}` ne peut être utilisé comme variable de compréhension" }
     , "Forbidden use of a \"dead\" variable name '{}' (Python101 rule)" : { 'fr' : "Il n'est pas autorisé en Python101 d'utiliser cette variable car le nom '{}' est déjà utilisé dans la fonction." }
-    , "Forbidden use of variable '{}' that is not in scope (Python101 scoping rule)" : { 'fr' : "La variable '{}' ne peut-être utilisée ici (règle de portée de Python101)." }
+    , "Forbidden use of variable '{}' that is not in scope (Python101 scoping rule)" : { 'fr' : "La variable '{}' ne peut être utilisée ici (règle de portée de Python101)." }
+    , "Forbidden use of global variable '{}' (Python101 rule)" : { 'fr' : "La variable '{}' est globale et ne peut être  utilisée dans une fonction (règle Python101)."}
     , "Type name error" : { 'fr' : "Erreur de type nommé" }
     , "I don't find any definition for the type: {}" : { 'fr' : "Je ne trouve pas de définition pour le type: {}" }
     , "Bad iterator" : { 'fr' : "Problème d'itération" }

mrpython/typechecking/typechecker.py

@@ -323,30 +323,6 @@ def type_check_Program(prog):
         else:
             ctx.register_function(fun_name, fun_type, fun_def)
 
-        ### XXX : old code for annotations
-        # else:
-        #     #print(repr(signature))
-        #     #print(fun_def.docstring)
-        #     signature = function_type_parser(fun_def.docstring)
-        #     if signature.iserror:
-        #         ctx.add_type_error(SignatureParseError(fun_name, fun_def, signature))
-        #     else: # HACK: trailing non-whistespace characters at the end of the signature
-        #         #parsed = fun_def.docstring[0:signature.end_pos.offset:]
-        #         #print("parsed = '{}'".format(parsed))
-        #         remaining = fun_def.docstring[signature.end_pos.offset:]
-        #         #print("remaining = '{}'".format(remaining))
-        #         if not fun_def.docstring[signature.end_pos.offset-1].isspace() and remaining and not remaining[0].isspace():
-        #             ctx.add_type_error(SignatureTrailingError(fun_name, fun_def, remaining))
-        #             # XXX: Not fatal ?
-        #         else:
-        #             fun_type, unknown_alias = signature.content.unalias(ctx.type_defs)
-        #             if fun_type is None:
-        #                 # position is a little bit ad-hoc
-        #                 ctx.add_type_error(UnknownTypeAliasError(signature.content, unknown_alias, fun_def.ast.lineno+ 1, fun_def.ast.col_offset + 7))
-        #                 return ctx
-        #             else:
-        #                 ctx.register_function(fun_name, fun_type, fun_def)
-
     # fourth step : type-check each function
     for (fun_name, fun_def) in ctx.functions.items():
         fun_def.type_check(ctx)
@@ -1060,7 +1036,7 @@ def ContainerAssign_type_check(cassign, ctx):
     if isinstance(container_type, DictType):
         if container_type.key_type is None:
             ctx.add_type_error(ContainerAssignEmptyError(cassign))
-        return False
+            return False
         key_type = container_type.key_type
         val_type = container_type.val_type
     elif isinstance(container_type, ListType):
@@ -1421,6 +1397,13 @@ def type_infer_EVar(var, ctx):
     if var.name in ctx.global_env:
         return ctx.global_env[var.name]
 
+    # or, is it a global variable ?
+    for global_var in ctx.prog.global_vars:
+        if isinstance(global_var, DeclareVar) and isinstance(global_var.target, LHSVar):
+            if var.name == global_var.target.var_name:
+                ctx.add_type_error(GlobalVariableUseError(var.name, var))
+                return None
+
     # or the variable is unknown
     ctx.add_type_error(UnknownVariableError(ctx.function_def, var))
     return None
@@ -3124,6 +3107,21 @@ def report(self, report):
         report.add_convention_error('error', tr("Bad variable"), self.node.ast.lineno, self.node.ast.col_offset
                                     , tr("Forbidden use of a \"dead\" variable name '{}' (Python101 rule)").format(self.var_name))
 
+class GlobalVariableUseError(TypeError):
+    def __init__(self, var_name, node):
+        self.var_name = var_name
+        self.node = node
+
+    def is_fatal(self):
+        return True
+
+    def fail_string(self):
+        return "GlobalVariableUseError[{}]@{}:{}".format(self.var_name, self.node.ast.lineno, self.node.ast.col_offset)
+
+    def report(self, report):
+        report.add_convention_error('error', tr("Bad variable"), self.node.ast.lineno, self.node.ast.col_offset
+                                    , tr("Forbidden use of global variable '{}' (Python101 rule)").format(self.var_name))
+
 class VariableTypeError(TypeError):
     def __init__(self, target, var, declared_type, var_type):
         self.target = target

mrpython/version.py

@@ -1,6 +1,6 @@
 MRPYTHON_VERSION_MAJOR = 5
 MRPYTHON_VERSION_MINOR = 1
-MRPYTHON_VERSION_PATCH = 5
+MRPYTHON_VERSION_PATCH = 6
 MRPYTHON_VERSION_TAG = "beta"
 
 

test/progs/46_dict_assign_OK.py

@@ -1,6 +1,7 @@
 
 def incrementer(d : Dict[str,int]) -> None:
-    """Incrémente tous les éléments du dictionnaire d.
+    """***Procedure***
+    Incrémente tous les éléments du dictionnaire d.
     """
     e : str
     for e in d:

test/progs/54_glob_ref_KO.py

@@ -0,0 +1,14 @@
+##!FAIL: GlobalVariableUseError[glob]@12:18
+
+glob : Dict[str,int] = {"test": 1}
+assert glob["test"] == 1
+
+def f(lst:List[str])-> Dict[str,float]:
+    """..."""
+    l : int = len(lst)
+    dic : Dict[str,float] = dict()
+    e:str
+    for e in lst:
+        dic[e] = (glob[e]/l)
+    return dic
+