Improve cross-language namebinding

Previously to enable cross-language scoping, we converted scoping types
from one language to another. For example, when embedding a Python method
into PHP, we renamed it to `function` so PHP's scoping rules could
reference it. This was restricitive as not every scope type has a true
representation in the other language. For example, in Python `method` can
be referenced by `variables`, which is not possible in PHP. Thus converting
`method` to `function` would disallow `method` to be referenced by a PHP
`variable`.

This commit changes how we treat namebinding information from language
boxes. When embedding Python into PHP, for example, Python's scoping rules
are merged into PHP's as is, keeping their specific types. We then extend
PHP's scoping rules, allowing them to reference Python types. For example,
a PHP `FunctionCall` now references `function` (PHP) and `method` (Python).

Author: ptersilie

lib/eco/astanalyser.py

@@ -239,49 +239,36 @@ def merge_lbox_data(self, node, path):
         analyser = self.get_lboxanalyser(root)
         analyser.analyse(root, self.parsers)
 
-        # convert variables, functions
-        if node.symbol.name == "<Python + PHP>":
-            # merge python into php
-            original = "variable"
-            dest = "function"
-            max_path = 1
-        elif node.symbol.name == "<PHP + Python>":
-            # merge php into python
-            original = "function"
-            dest = "variable"
-            max_path = 1
-        else:
-            return
-        for method in analyser.data.get(original,[]):
-            if len(method.path) > max_path:
+        for kind in analyser.data:
+            if kind in ["File", "reference"]:
                 continue
-            uri = self.convert_uri(dest, method, path)
-            uri.nbrule = NBRule("none", [], {})
-            self.add_uri(uri)
+            for obj in analyser.data[kind]:
+                uri = self.convert_uri(kind, obj, path)
+                self.add_uri(uri)
 
         # convert references
         for ref in analyser.data.get("reference",[]):
             # if reference couldn't be resolved, try in outer lbox
             if ref.node in analyser.errors:
                 del analyser.errors[ref.node]
                 uri = self.convert_uri("reference", ref, path)
-                if uri.name.startswith("$"):
+                if uri.name.startswith("$"): # XXX PHP hack
                     uri.name = uri.name[1:]
-                else:
-                    uri.name = "$" + uri.name
-                uri.nbrule = NBRule("none", [], {"references":(["variable"], ["function"])})
+                uri.nbrule = NBRule("none", [], {"references":(["variable", "function"], ["name"])})
                 self.add_uri(uri)
         return
 
     def convert_uri(self, newkind, prev, path):
-        uri = URI()
-        uri.kind = newkind
-        uri.astnode = prev.astnode
-        uri.node = prev.node
-        uri.path = path
-        uri.name = prev.name
-        uri.vartype = prev.vartype
-        uri.index = self.index
+        uri = prev
+        if len(prev.path) >= 1:
+            # Replace language box's top level with current location
+            uri.path.pop(0)
+            for p in reversed(path):
+                uri.path.insert(0, p)
+        else:
+            # Language box has no top-level (subgrammar)
+            for p in reversed(path):
+                uri.path.insert(0, p)
         return uri
 
     def add_uri(self, uri):

lib/eco/eco.py

@@ -1385,9 +1385,10 @@ def btReparse(self, selected_node=[]):
     def updateASTOutline(self):
         self.ui.tw_astoutline.clear()
         aa = self.getEditor().tm.parsers[0][3]
-        for uri in aa.data["class"]:
-            if uri.path[0].name is None and len(uri.path) == 1:
-                self.addToASTOutline(aa, uri, self.ui.tw_astoutline)
+        if aa.data.has_key("class"):
+            for uri in aa.data["class"]:
+                if not uri.path or (uri.path and uri.path[0].name is None and len(uri.path) == 1):
+                    self.addToASTOutline(aa, uri, self.ui.tw_astoutline)
         self.ui.tw_astoutline.expandAll()
 
     def addToASTOutline(self, aa, uri, parent):

lib/eco/grammars/grammars.py

@@ -19,6 +19,8 @@
 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 # IN THE SOFTWARE.
 
+import os
+
 class Language(object):
 
     def __init__(self, name, grammar, priorities, base=""):
@@ -51,6 +53,7 @@ def __init__(self, name, filename, base=""):
         self.extract = None
         self.auto_include = None
         self.auto_exclude = None
+        self.nb_file = os.path.splitext(filename)[0] + ".nb"
 
     def load(self, buildlexer=True):
         from grammar_parser.bootstrap import BootstrapParser
@@ -118,6 +121,9 @@ def set_auto_exclude(self, lang, tokentype):
             self.auto_exclude = {}
         self.auto_exclude[lang] = tokentype
 
+    def set_custom_nb(self, basename):
+        self.nb_file = "{}/{}".format(os.path.dirname(self.filename), basename)
+
     def auto_allows(self, lang, tokentype):
         if self.auto_include and self.auto_include.has_key(lang):
             return tokentype in self.auto_include[lang]
@@ -194,6 +200,7 @@ def __hash__(self):
 python_class.change_start("classdef")
 
 phppython = EcoFile("PHP + Python", "grammars/php.eco", "Php")
+phppython.set_custom_nb("phppython.nb")
 pythonphp = EcoFile("Python + PHP", "grammars/python275.eco", "Python")
 phppython.add_alternative("top_statement", pythonphp)
 phppython.add_alternative("class_statement", pythonphp)

lib/eco/grammars/phppython.nb

@@ -146,9 +146,9 @@ def resizeEvent(self, event):
 
     def analysis_timer(self):
         if self.getWindow().show_namebinding():
-            self.tm.analyse()
-            self.update()
-            self.getWindow().updateASTOutline()
+            if self.tm.analyse() is not False:
+                self.update()
+                self.getWindow().updateASTOutline()
         self.timer.stop()
 
         # save swap

lib/eco/grammars/python275.nb

@@ -544,10 +544,12 @@ def load_analyser(self, language):
             return
         if isinstance(lang, EcoFile):
             import os
-            filename = os.path.splitext(lang.filename)[0] + ".nb"
-            if os.path.exists(filename):
+            if os.path.exists(lang.nb_file):
                 from astanalyser import AstAnalyser
-                return AstAnalyser(filename)
+                return AstAnalyser(lang.nb_file)
+            else:
+                print("Namebinding file '%s' not found." % (lang.nb_file))
+
 
     def get_languagebox(self, node):
         root = node.get_root()
@@ -604,10 +606,20 @@ def get_error_presentation(self, node):
         return None
 
     def analyse(self):
-        if self.parsers[0][2] == "PHP + Python":
-            self.parsers[0][3].analyse(self.parsers[0][0].previous_version.parent, self.parsers)
+        # for now only do cross-scope analysing for certain grammars
+        crossscope = ["PHP + Python", "Java + Python"]
+        lang = self.parsers[0][2]
+        parser = self.parsers[0][0]
+        analyser = self.parsers[0][3]
+
+        if not analyser:
+            return False
+
+        if lang in crossscope:
+            analyser.analyse(parser.previous_version.parent, self.parsers)
             return
 
+        # analyse all parsers individually
         for p in self.parsers:
             if p[0].last_status:
                 if p[3]: