module aliases halfway

Author: JdeH

transcrypt/development/automated_tests/transcrypt/nonlocals/autotest.py

@@ -0,0 +1,118 @@
+from org.transcrypt.stubs.browser import __pragma__
+import org.transcrypt.autotester
+
+import arguments
+import attribs_by_name
+import builtin_super
+import byte_arrays
+import callable_test
+import classes
+import complex_numbers
+import conditional_expressions
+import control_structures
+
+if __pragma__ ('defined', '__py3.7__'):
+    import dashed_numbers
+
+import data_classes
+import data_structures
+import decorators
+import dict_comprehensions
+import dictionaries
+import div_issues
+import div_pulls
+import docstrings
+import exceptions
+import extended_slices
+import fstrings
+import general_functions
+import globals_function
+import indices_and_slices
+import iterators_and_generators
+import lambda_functions
+import list_comprehensions
+import local_classes
+import metaclasses
+import method_and_class_decorators
+import module_builtin
+import module_cmath
+
+if __pragma__ ('defined', 'undefined'):
+    import module_collections
+
+import module_datetime
+import module_itertools
+import module_math
+import module_unicodedata
+import modules
+import nonlocals
+import operator_overloading
+import properties
+import proxies
+import reprtest
+import set_comprehensions
+import simple_and_augmented_assignment
+
+if __pragma__ ('defined', '__sform__'):
+    import string_format
+
+import truthyness
+import tuple_assignment
+
+autoTester = org.transcrypt.autotester.AutoTester ()
+autoTester.run (arguments, 'arguments')
+autoTester.run (attribs_by_name, 'attribs_by_name')
+autoTester.run (builtin_super, 'builtin_super')
+autoTester.run (byte_arrays, 'byte_arrays')
+autoTester.run (callable_test, 'callable')
+autoTester.run (classes, 'classes')
+autoTester.run (complex_numbers, 'complex_numbers')
+autoTester.run (conditional_expressions, 'conditional_expressions')
+autoTester.run (control_structures, 'control_structures')
+autoTester.run (dashed_numbers, 'dashed_numbers')
+autoTester.run (data_classes, 'data_classes')
+autoTester.run (data_structures, 'data_structures')
+autoTester.run (decorators, 'decorators')
+autoTester.run (dict_comprehensions, 'dict_comprehensions')
+autoTester.run (dictionaries, 'dictionaries')
+autoTester.run (div_issues, 'div_issues')
+autoTester.run (div_pulls, 'div_pulls')
+autoTester.run (docstrings, 'docstrings')
+autoTester.run (exceptions, 'exceptions')
+autoTester.run (extended_slices, 'extended_slices')
+autoTester.run (fstrings, 'fstrings')
+autoTester.run (general_functions, 'general_functions')
+autoTester.run (globals_function, 'globals_function')
+autoTester.run (indices_and_slices, 'indices_and_slices')
+autoTester.run (iterators_and_generators, 'iterators_and_generators') 
+autoTester.run (lambda_functions, 'lambda_functions')
+autoTester.run (list_comprehensions, 'list_comprehensions')
+autoTester.run (local_classes, 'local_classes')
+autoTester.run (metaclasses, 'metaclasses')
+autoTester.run (method_and_class_decorators, 'method_and_class_decorators')
+autoTester.run (module_builtin, 'module_builtin')
+autoTester.run (module_cmath, 'module_cmath')
+
+if __pragma__ ('defined', 'undefined'):
+    autoTester.run (module_collections, 'module_collections')
+
+autoTester.run (module_datetime, 'module_datetime')
+autoTester.run (module_itertools, 'module_itertools')
+autoTester.run (module_math, 'module_math')
+autoTester.run (module_unicodedata, 'module_unicodedata')
+autoTester.run (modules, 'modules')
+autoTester.run (nonlocals, 'nonlocals')
+autoTester.run (operator_overloading, 'operator_overloading')
+autoTester.run (properties, 'properties')
+autoTester.run (reprtest, 'repr_str')
+autoTester.run (proxies, 'proxies')
+autoTester.run (set_comprehensions, 'set_comprehensions')
+autoTester.run (simple_and_augmented_assignment, 'simple_and_augmented_assignment')
+
+if __pragma__ ('defined', '__sform__'):
+    autoTester.run (string_format, 'string_format')
+ 
+autoTester.run (truthyness, 'truthyness')
+autoTester.run (tuple_assignment, 'tuple_assignment')
+
+autoTester.done ()

transcrypt/development/manual_tests/import_export_aliases/test-modules-b/specific-module-b.js

@@ -0,0 +1,3 @@
+export function bFunction (aPrint) {
+    aPrint.check ('B function called<br>');
+};

transcrypt/development/manual_tests/import_export_aliases/test.html

@@ -0,0 +1,19 @@
+<html>
+	<head>
+		<style>
+			#__terminal__ {
+				width: 100%;
+				height: 100%;
+				background-color: black;
+				color: white;
+				font-family: arial;
+				font-size: 14px;
+			}
+		</style>
+	</head>
+	<body>
+        <div id="__terminal__">
+        <div>
+        <script type="module">import * as hello from "./__target__/test.js";</script>
+	</body>
+</html>

transcrypt/development/manual_tests/import_export_aliases/test.py

@@ -0,0 +1,23 @@
+# __pragma__ ('alias', 'specific_module_a', 'specific-module-a')
+# __pragma__ ('alias', 'S', '$')
+
+# __pragma__ ('alias', 'test_modules_b', 'test-modules-b')
+# __pragma__ ('alias', 'specific_module_b', 'specific-module-b')
+
+# x__pragma__ ('alias', 'specific_submodule_c', 'specific-submodule-c')
+
+from test_modules_a.__specific_module_a import a__S__Function
+from test_modules_b__.__specific_module_b import bFunction as theBFunction
+from test_modules_c.specific_module_c import *
+
+def aPrint (any):
+    document.getElementById ('__terminal__') .innerHTML += str (any)
+
+def run (autoTester):
+    the__S__Variable = 3
+    aPrint (the__S__Variable)
+
+    a__S__Function (aPrint)
+    theBFunction (aPrint)
+    test_modules_c.specific_module_c.specific_submodule_c.c__S__Function (aPrint)
+    

transcrypt/development/manual_tests/import_export_aliases/test_modules_a/specific-module-a.js

@@ -0,0 +1,3 @@
+export function a$Function (aPrint) {
+    aPrint ('A function called<br>');
+};

transcrypt/development/manual_tests/import_export_aliases/test_modules_c/specific_module_c.py

@@ -0,0 +1,3 @@
+# x__pragma__ ('alias', 'specific_submodule_c', 'specific-submodule-c')
+
+import test_modules_c.specific_submodule_c

transcrypt/development/manual_tests/import_export_aliases/test_modules_c/specific_submodule_c.js

@@ -0,0 +1,3 @@
+export function c$Function (aPrint) {
+    aPrint.check ('C function called<br>');
+};

transcrypt/modules/org/transcrypt/compiler.py

@@ -106,14 +106,14 @@ def __init__ (
                 message = f'\n\t{exception}'
             )
 
-    def provide (self, moduleName, __moduleName__ = None):    
+    def provide (self, filteredModuleName, __moduleName__ = None):    
         # moduleName may contain dots if it's imported, but it'll have the same name in every import
 
-        if moduleName in self.moduleDict:  # Find out if module is already provided
-            return self.moduleDict [moduleName]
+        if filteredModuleName in self.moduleDict:  # Find out if module is already provided
+            return self.moduleDict [filteredModuleName]
         else:                              # If not, provide by loading or compiling
-            # This may fail legally if moduleName ends on a name of something in a module, rather than of the module itself
-            return Module (self, moduleName, __moduleName__)
+            # This may fail legally if filteredModuleName ends on a name of something in a module, rather than of the module itself
+            return Module (self, filteredModuleName, __moduleName__)
 
 class Module:
     def __init__ (self, program, name, __name__ = None):      
@@ -230,6 +230,8 @@ def __init__ (self, program, name, __name__ = None):
         self.exportedNames = javascriptDigest.exportedNames
 
         for importedModuleName in self.importedModuleNames:
+        
+            # Unfiltered hyphens allowed, since we may be in a JavaScript-only part of the module hierarchy
             self.program.provide (importedModuleName)
 
         # Remove eventual intermediate files
@@ -242,7 +244,7 @@ def __init__ (self, program, name, __name__ = None):
 
     def findPaths (self):
         searchedModulePaths = []
-                
+                        
         relSourceSlug = self.name.replace ('.', '/')
         for searchDir in self.program.moduleSearchDirs:
             # Find source slugs
@@ -608,13 +610,13 @@ def getPriority (exprNode):
 
     def getAliaser (self, sourceFragment, targetFragment):
         return (sourceFragment, re.compile ('''
-            (^{0}$)|            # Whole word
-            (.+__{0}__.+)|      # Truly contains __<pyFragment>__ (Truly, so spare e.g. __name__)
-            (^{0}__)|           # Starts with <pyFragment>__
-            (__{0}$)|           # Ends with __<pyFragment>
-            ((?<=\.){0}__)|     # Starts with '.<pyFragment>__'
-            (__{0}(?=\.))       # Ends with '__<pyFragment>.'
-        '''.format (sourceFragment), re.VERBOSE), targetFragment)
+            (^{0}$)|                # Whole word
+            ((.+)(__{0}__)(.+))|    # Truly contains __<pyFragment>__ (Truly, so spare e.g. __name__)
+            (^{0}__)|               # Starts with <pyFragment>__
+            (__{0}$)|               # Ends with __<pyFragment>
+            ((?<=\.){0}__)|         # Starts with '.<pyFragment>__'
+            (__{0}(?=\.))           # Ends with '__<pyFragment>.'
+        '''.format (sourceFragment), re.VERBOSE), fr'\3{targetFragment}\5')
 
     def filterId (self, qualifiedId):   # Convention: only called at emission time
         if self.idFiltering:
@@ -818,8 +820,14 @@ def prevTemp (self, name):
             del self.tempIndices [name]
 
     def useModule (self, name):
-        self.module.program.importStack [-1][1] = self.lineNr   # Remember line nr of import statement for the error report
-        return self.module.program.provide (name)               # Must be done first because it can generate a healthy exception
+        self.module.program.importStack [-1][1] = self.lineNr       # Remember line nr of import statement for the error report
+        
+        # Filter to get hyphen in name if a suitable alias is defined
+        # Filtering has to be done early, since the hyphen has to be used in the filename when loading the module
+        # The filename for this is made by the Program class, that doesn't have pragma's available
+        # So name has to be passed "ready made"
+        
+        return self.module.program.provide (self.filterId (name) if utils.commandArgs.alimod else name)   # Must be done first because it can generate a healthy exception
 
     def isCall (self, node, name):
         return type (node) == ast.Call and type (node.func) == ast.Name and node.func.id == name
@@ -2861,6 +2869,7 @@ def revisit_ImportFrom (self, node):  # From ... import ... can import modules o
                     try:                                                        # Try if alias.name denotes a module
                         module = self.useModule ('{}.{}'.format (node.module, alias.name))
                         self.emit ('import * as {} from \'{}\';\n', self.filterId (alias.asname) if alias.asname else self.filterId (alias.name), module.importRelPath)
+                        # self.allImportedNames.add(alias.asname or alias.name)   # add import to allImportedNames of this module
                     except:                                                     # If it doesn't it denotes a facility inside a module
                         module = self.useModule (node.module)
                         namePairs.append (utils.Any (name = alias.name, asName = alias.asname))      
@@ -3004,7 +3013,7 @@ def visit_Module (self, node):
         self.importHoistFragmentIndex = self.fragmentIndex       
 
         # Let the module know its __name__
-        self.emit ('var __name__ = \'{}\';\n', self.module.__name__)
+        self.emit ('var __name__ = \'{}\';\n', self.module.__name__)    # ??? Needs filterId ?
         self.allOwnNames.add ('__name__')
 
         # Generate code for the module body
@@ -3051,7 +3060,7 @@ def visit_Module (self, node):
                 ])
                 +
                 '}});\n'            
-            )
+            )   # ??? Needs filterid?
 
         # Import other modules (generatable only late, but hoisted) and nest them into the import heads
         # The import head definitions are generated later but inserted before the imports
@@ -3065,7 +3074,7 @@ def visit_Module (self, node):
         # Transit export of imported facilities (so no facilities that weren't imported and no modules)
         if utils.commandArgs.xreex or self.module.sourcePrename == '__init__':
             if self.allImportedNames:
-                self.emit ('export {{{}}};\n', ', '.join (self.allImportedNames))     # This does emit an export list
+                self.emit ('export {{{}}};\n', ', '.join ([self.filterId (importedName) for importedName in self.allImportedNames]))     # This emits an export list
 
         # Import runtime module (generatable only late, but hoisted)
         # Place it first, but decimate its imported names last, since they should appear to be overriden by later imports

transcrypt/modules/org/transcrypt/utils.py

@@ -37,6 +37,7 @@ def parse (self):
 
         self.argParser.add_argument ('source', nargs='?', help = ".py file containing source code of main module")
         self.argParser.add_argument ('-a', '--anno', help = "annotate target files that were compiled from Python with source file names and source line numbers", action = 'store_true')
+        self.argParser.add_argument ('-am', '--alimod', help = "use aliasing for module paths", action = 'store_true')
         self.argParser.add_argument ('-b', '--build', help = "rebuild all target files from scratch", action = 'store_true')
         self.argParser.add_argument ('-c', '--complex', help = "enable complex number support, locally requires operator overloading", action = 'store_true')
         self.argParser.add_argument ('-d', '--docat', help = "enable __doc__ attributes. Apply sparsely, since it will make docstrings part of the generated code", action = 'store_true')
@@ -297,7 +298,7 @@ def __pragma__ (name, *args):
 
     namesPattern = re.compile ('({.*})')
     pathPattern = re.compile ('([\'|\"].*[\'|\"])')
-    wordPattern = re.compile (r'\w+')
+    wordPattern = re.compile (r'[\w+$]')
     for line in passableLines:
         words = wordPattern.findall (line)
 
@@ -320,7 +321,7 @@ def __pragma__ (name, *args):
 
                     # Substitute to become "{'p', 'q', 'r', 's'}" and use that set to extend the exported names list
                     if match:
-                        result.exportedNames.extend (eval (re.sub (r'\w+', lambda nameMatch: f'\'{nameMatch.group ()}\'', match.group (1))))
+                        result.exportedNames.extend (eval (wordPattern.sub (lambda nameMatch: f'\'{nameMatch.group ()}\'', match.group (1))))
 
             if words [0] == 'import':
                 # Deducing imported modules from JavaScript is needed to provide the right modules to JavaScript-only modules