Rename function lookup to make its name more consistent with another function

Author: sungshik

rascal-textmate-core/src/main/rascal/lang/oniguruma/Conversion.rsc

@@ -60,15 +60,15 @@ RegExp toRegExp(Grammar g, list[Symbol] symbols, set[Attr] attributes) {
 RegExp toRegExp(Grammar g, \label(_, symbol))
     = toRegExp(g, symbol);
 RegExp toRegExp(Grammar g, \parameter(_, _)) {
-    throw "Presumably unreachable..."; } // Covered by `lookup` (which substitutes actuals for formals)
+    throw "Presumably unreachable..."; } // Covered by `prodsOf` (which substitutes actuals for formals)
 
 // `ParseTree`: Start
 RegExp toRegExp(Grammar g, \start(symbol))
     = toRegExp(g, symbol);
 
 // `ParseTree`: Non-terminals
 RegExp toRegExp(Grammar g, Symbol s)
-    = infix("|", [toRegExp(g, p) | p <- lookup(g, s)]) when isNonTerminalType(s);
+    = infix("|", [toRegExp(g, p) | p <- prodsOf(g, s)]) when isNonTerminalType(s);
 
 // `ParseTree`: Terminals
 RegExp toRegExp(Grammar _, \lit(string))
@@ -103,7 +103,7 @@ RegExp toRegExp(Grammar g, \conditional(symbol, conditions)) {
     prefixConditions = [c | c <- conditions, isPrefixCondition(c)];
     suffixConditions = [c | c <- conditions, isSuffixCondition(c)];
     deleteConditions = [c | c <- conditions, isDeleteCondition(c)];
-    
+
     // Convert except conditions (depends on previous conversion)
     if (_ <- exceptConditions) {
         if (/\choice(symbol, alternatives) := g) {
@@ -112,7 +112,7 @@ RegExp toRegExp(Grammar g, \conditional(symbol, conditions)) {
                 = \label(l, _) := def
                 ? \except(l) notin exceptConditions
                 : true;
-            
+
             re = infix("|", toRegExps(g, {a | a <- alternatives, keep(a)}));
         }
     }
@@ -130,7 +130,7 @@ RegExp toRegExp(Grammar g, \conditional(symbol, conditions)) {
     // Convert delete conditions (depends on previous conversions)
     if (_ <- deleteConditions) {
         RegExp delete = infix("|", [toRegExp(g, s) | \delete(s) <- deleteConditions]);
-            
+
         // TODO: Explain this complicated conversion...
         str string = "(?=(?\<head\><re.string>)(?\<tail\>.*)$)(?!(?:<delete.string>)\\k\<tail\>$)\\k\<head\>";
         list[str] categories = ["", *re.categories, "", *delete.categories];
@@ -196,7 +196,7 @@ str encode(int char) = preEncoded[char] ? "\\x{<toHex(char)>}";
 private set[int] charRange(str from, str to) = {*[charAt(from, 0)..charAt(to, 0) + 1]};
 
 private str toHex(int i)
-    = i < 16 
+    = i < 16
     ? hex[i]
     : toHex(i / 16) + toHex(i % 16);
 

rascal-textmate-core/src/main/rascal/lang/rascal/grammar/Util.rsc

@@ -40,8 +40,8 @@ bool tryParse(Grammar g, Symbol s, str input, bool allowAmbiguity = false) {
 bool isRecursive(Grammar g, Symbol s, set[Symbol] checking = {})
     = s in checking
     ? true
-    : any(p <- lookup(g, delabel(s)),
-          /Symbol child := p.symbols, 
+    : any(p <- prodsOf(g, delabel(s)),
+          /Symbol child := p.symbols,
           isRecursive(g, child, checking = checking + s));
 
 @synopsis{
@@ -72,7 +72,7 @@ alias Pointer = tuple[Production p, int index];
 
     ```
     lexical X  = Y;
-    lexical Y  = alt1: "[" "[" "[" Z1 "]" "]" "]" | alt2: "<" Z2 ">"; 
+    lexical Y  = alt1: "[" "[" "[" Z1 "]" "]" "]" | alt2: "<" Z2 ">";
     lexical Z1 = "foo" "bar";
     lexical Z2 = "baz";
     ```
@@ -82,7 +82,7 @@ alias Pointer = tuple[Production p, int index];
       - `<X,0>`
       - `<Y.alt1,3>`
       - `<Z1,1>`
-    
+
     The list of pointers to `"qux"` is just empty.
 }
 
@@ -94,7 +94,7 @@ list[Pointer] find(Grammar g, Production p, Symbol s, Direction dir = forward())
             if (ith == needle) {
                 return [<haystack, i>];
             }
-            for (isNonTerminalType(ith), child <- lookup(g, ith)) {
+            for (isNonTerminalType(ith), child <- prodsOf(g, ith)) {
                 if (list[Pointer] l: [_, *_] := doFind(doing + haystack, child, s)) {
                     return [<haystack, i>] + l;
                 }
@@ -108,30 +108,26 @@ list[Pointer] find(Grammar g, Production p, Symbol s, Direction dir = forward())
 }
 
 @synopsis{
-    Lookdowns a list of productions for symbol `s` in grammar `g`
+    Gets the list of productions that contain symbol `s` in grammar `g`
 }
 
-// TODO: Rename this function because the current name makes little sense in
-// isolation (it's supposed to be the opposite of `lookup`, but in that sense,
-// the directions are illogical)
-
-set[Production] lookdown(Grammar g, Symbol s)
+set[Production] prodsWith(Grammar g, Symbol s)
     = {parent | /parent: prod(_, /Symbol _: s, _) := g};
 
 @synopsis{
-    Lookups a list of productions for symbol `s` in grammar `g`, replacing
+    Gets the list of productions of symbol `s` in grammar `g`, replacing
     formal parameters with actual parameters when needed
 }
 
-list[Production] lookup(Grammar g, s: \parameterized-sort(name, actual))
+list[Production] prodsOf(Grammar g, s: \parameterized-sort(name, actual))
     = [subst(p, formal, actual) | /p: prod(\parameterized-sort(name, formal), _, _) := g.rules[s] ? []]
     + [subst(p, formal, actual) | /p: prod(label(_, \parameterized-sort(name, formal)), _, _) := g.rules[s] ? []];
 
-list[Production] lookup(Grammar g, s: \parameterized-lex(name, actual))
+list[Production] prodsOf(Grammar g, s: \parameterized-lex(name, actual))
     = [subst(p, formal, actual) | /p: prod(\parameterized-lex(name, formal), _, _) := g.rules[s] ? []]
     + [subst(p, formal, actual) | /p: prod(label(_, \parameterized-lex(name, formal)), _, _) := g.rules[s] ? []];
 
-default list[Production] lookup(Grammar g, Symbol s)
+default list[Production] prodsOf(Grammar g, Symbol s)
     = [p | /p: prod(s, _, _) := g.rules[s] ? []]
     + [p | /p: prod(label(_, s), _, _) := g.rules[s] ? []];
 
@@ -143,7 +139,7 @@ default list[Production] lookup(Grammar g, Symbol s)
 &T subst(&T t, list[Symbol] from, list[Symbol] to)
     = subst(t, toMapUnique(zip2(from, to)))
     when size(from) == size(to);
-    
+
 private &T subst(&T t, map[Symbol, Symbol] m)
     = visit (t) { case Symbol s => m[s] when s in m };
 

rascal-textmate-core/src/main/rascal/lang/rascal/grammar/analyze/Categories.rsc

@@ -33,7 +33,7 @@ private map[Production, set[str]] getCategoriesByProduction(Grammar g) {
 
         // If the new categories of `p` are different from the old ones, then
         // propagate these changes to the children of `p`
-        for (old != new, /Symbol s := p.symbols, child <- lookup(g, delabel(s))) {
+        for (old != new, /Symbol s := p.symbols, child <- prodsOf(g, delabel(s))) {
             doGet(child, new);
         }
     }

rascal-textmate-core/src/main/rascal/lang/rascal/grammar/analyze/Delimiters.rsc

@@ -49,7 +49,7 @@ DelimiterPair getInnerDelimiterPair(Grammar g, Symbol s, bool getOnlyFirst = fal
     ```
     lexical X  = Y;
     lexical Y  = Y1 | Y2;
-    lexical Y1 = "[" Z "]"; 
+    lexical Y1 = "[" Z "]";
     lexical Y2 = "[" Z ")" [a-z];
     lexical Z  = [a-z];
     ```
@@ -83,7 +83,7 @@ private map[Symbol, Maybe[Symbol]] getInnerDelimiterBySymbol(Grammar g, Directio
 @memo
 private map[Production, Maybe[Symbol]] getInnerDelimiterByProduction(Grammar g, Direction direction, bool getOnlyFirst = false) {
     map[Production, Maybe[Symbol]] ret = (p: nothing() | /p: prod(_, _, _) := g);
-        
+
     solve (ret) {
         for (p <- ret, ret[p] == nothing()) {
             for (s <- reorder(p.symbols, direction)) {
@@ -108,7 +108,7 @@ private map[Production, Maybe[Symbol]] getInnerDelimiterByProduction(Grammar g,
 }
 
 private set[Production] getChildren(Grammar g, Symbol s)
-    = {*lookup(g, s)};
+    = {*prodsOf(g, s)};
 
 @synopsis{
     Gets the unique rightmost delimiter (`begin`) and the unique leftmost
@@ -122,7 +122,7 @@ private set[Production] getChildren(Grammar g, Symbol s)
     ```
     lexical X  = Y;
     lexical Y  = Y1 | Y2;
-    lexical Y1 = "[" Z "]"; 
+    lexical Y1 = "[" Z "]";
     lexical Y2 = "[" Z ")" [a-z];
     lexical Z  = [a-z];
     ```
@@ -166,7 +166,7 @@ private map[Symbol, Maybe[Symbol]] getOuterDelimiterBySymbol(Grammar g, Directio
             ret[s] = unique(delimiters);
         }
     }
-    
+
     return ret;
 }
 

rascal-textmate-core/src/main/rascal/lang/rascal/grammar/analyze/Newlines.rsc

@@ -55,7 +55,7 @@ private map[Production, Maybe[set[Segment]]] getSegmentsByProduction(Grammar g)
 }
 
 private Maybe[set[Segment]] getSegmentsWithEnvironment(
-        Grammar g, list[Symbol] symbols, 
+        Grammar g, list[Symbol] symbols,
         map[Production, Maybe[set[Segment]]] env) {
 
     // General idea: Recursively traverse `symbols` from left to right, while
@@ -73,9 +73,9 @@ private Maybe[set[Segment]] getSegmentsWithEnvironment(
         set[Symbol] nested = {s | /Symbol s := head};
 
         Maybe[set[Segment]] finished = get(running, [], final = tail == []);
-        
+
         // If the head contains a non-terminal, then: (1) finish the running
-        // segment; (2) lookup the segments of the non-terminals in the
+        // segment; (2) look up the segments of the non-terminals in the
         // environment, if any; (3) compute the segments of the tail. Return the
         // union of 1-3.
         if (any(s <- nested, isNonTerminalType(s))) {
@@ -85,15 +85,15 @@ private Maybe[set[Segment]] getSegmentsWithEnvironment(
             sets += finished;
 
             // (2)
-            sets += for (s <- nested, isNonTerminalType(s), p <- lookup(g, s)) {
+            sets += for (s <- nested, isNonTerminalType(s), p <- prodsOf(g, s)) {
 
                 bool isInitial(Segment seg)
                     = seg.initial && running.initial && running.symbols == [];
                 bool isFinal(Segment seg)
                     = seg.final && tail == [];
                 Segment update(Segment seg)
                     = seg[initial = isInitial(seg)][final = isFinal(seg)];
-                
+
                 append just(segs) := env[p] ? just({update(seg) | seg <- segs}) : nothing();
             }
 
@@ -103,21 +103,21 @@ private Maybe[set[Segment]] getSegmentsWithEnvironment(
             // Return union
             return (sets[0] | union(it, \set) | \set <- sets[1..]);
         }
-        
+
         // If the head doesn't contain a non-terminal, but it has a newline,
         // then: (1) finish the running segment; (2) compute the segments of the
         // tail. Return the union of 1-2. Note: the head, as it has a newline,
         // is ignored and won't be part of any segment.
         else if (any(s <- nested, hasNewline(g, s))) {
             return union(finished, get(segment([]), tail));
         }
-        
+
         // If the head doesn't contain a non-terminal, and if it doesn't have a
         // newline, then add the head to the running segment and proceed with
         // the tail.
         else {
             Segment old = running;
-            Segment new = old[symbols = old.symbols + head]; 
+            Segment new = old[symbols = old.symbols + head];
             return get(new, tail);
         }
     }
@@ -130,7 +130,7 @@ private Maybe[set[Segment]] getSegmentsWithEnvironment(
 }
 
 bool hasNewline(Grammar g, Symbol s) {
-    return any(p <- lookup(g, delabel(s)), hasNewline(g, p));
+    return any(p <- prodsOf(g, delabel(s)), hasNewline(g, p));
 }
 
 @synopsis{
@@ -149,7 +149,7 @@ private map[Production, bool] hasNewlineByProduction(Grammar g) {
         for (p <- ret, !ret[p]) {
             set[Symbol] nonTerminals = {s | /Symbol s := p.symbols, isNonTerminalType(s)};
             ret[p] = ret[p] || any(/r: range(_, _) := p.symbols, hasNewline(r))
-                            || any(s <- nonTerminals, Production child <- lookup(g, s), ret[child]);
+                            || any(s <- nonTerminals, Production child <- prodsOf(g, s), ret[child]);
         }
     }
 
@@ -165,7 +165,7 @@ private map[Production, bool] hasNewlineByProduction(Grammar g) {
 
 bool hasNewline(str s)
     = LF in chars(s);
-    
+
 bool hasNewline(range(begin, end))
     = begin <= LF && LF <= end;
 

rascal-textmate-core/src/main/rascal/lang/rascal/grammar/analyze/Symbols.rsc

@@ -56,7 +56,7 @@ private map[Symbol, Maybe[set[Symbol]]] firstBySymbol(Grammar g, bool(Symbol) pr
         for (s <- ret, nothing() == ret[s]) {
             if (predicate(s)) {
                 ret[s] = just({s});
-            } else if (list[Production] prods: [_, *_] := lookup(g, s)) {
+            } else if (list[Production] prods: [_, *_] := prodsOf(g, s)) {
                 ret[s] = (just({}) | union(it, firstOf(reorder(p.symbols, dir))) | p <- prods);
             } else {
                 ret[s] = just({\empty()});
@@ -84,7 +84,7 @@ set[Symbol] follow(Grammar g, Symbol s)
 @memo
 private map[Symbol, Maybe[set[Symbol]]] followBySymbol(Grammar g, bool(Symbol) predicate, Direction dir) {
     map[Symbol, Maybe[set[Symbol]]] ret = (delabel(s): nothing() | s <- g.rules); // Non-terminals
-    
+
     Maybe[set[Symbol]] followOf(Symbol parent, [])
         = ret[delabel(parent)];
     Maybe[set[Symbol]] followOf(Symbol parent, [h, *t])

rascal-textmate-core/src/main/rascal/lang/textmate/Conversion.rsc

@@ -131,15 +131,15 @@ private RscGrammar replaceLegacySemanticTokenTypes(RscGrammar rsc)
       - one synthetic *delimiters* production;
       - zero-or-more *user-defined* productions (from `rsc`);
       - one synthetic *keywords* production.
-    
+
     Each production in the list (including the synthetic ones) is *suitable for
     conversion* to a TextMate rule. A production is "suitable for conversion"
     when it satisfies each of the following conditions:
       - it is non-recursive;
       - it does not match newlines;
       - it does not match the empty word;
       - it has a `@category` tag.
-    
+
     See the walkthrough for further motivation and examples.
 }
 
@@ -187,7 +187,7 @@ list[ConversionUnit] analyze(RscGrammar rsc, str name) {
 
         // If each parent of `p` has a category, then ignore `p` (the parents of
         // `p` will be used for highlighting instead)
-        set[Production] parents = lookdown(rsc, delabel(p.def));
+        set[Production] parents = prodsWith(rsc, delabel(p.def));
         if (!any(parent <- parents, NO_CATEGORY in getCategories(rsc, parent))) {
             continue;
         }
@@ -295,7 +295,7 @@ private list[ConversionUnit] addInnerRules(list[ConversionUnit] units) {
             bool guard = nothing() := u.innerDelimiters.begin;
             TmRule r = toTmRule(toRegExp(u.rsc, u.prod, guard = guard))
                        [name = "/inner/single/<u.name>"];
-            
+
             rules = insertIn(rules, (u: r));
         }
 
@@ -311,18 +311,18 @@ private list[ConversionUnit] addInnerRules(list[ConversionUnit] units) {
 
             // Simple case: each unit does have an `end` inner delimiter
             if (_ <- group && all(u <- group, just(_) := u.innerDelimiters.end)) {
-                
-                // Create a set of pointers to the first (resp. last) occurrence 
+
+                // Create a set of pointers to the first (resp. last) occurrence
                 // of `pivot` in each unit, when `pivot` is a `begin` delimiter
                 // (resp. an `end` delimiter) of the group. If `pivot` occurs
                 // elsewhere in the grammar as well, then skip the conversion
                 // of these multi-line units to a begin/end pattern. This is to
                 // avoid tokenization mistakes in which the other occurrences of
                 // `pivot` in the input are mistakenly interpreted as the
                 // beginning or ending of a unit in the group.
-                
+
                 Symbol pivot = key.val;
-                
+
                 set[Pointer] pointers = {};
                 pointers += pivot in begins ? {*find(rsc, u.prod, pivot, dir = forward()) [-1..] | u <- group} : {};
                 pointers += pivot in ends   ? {*find(rsc, u.prod, pivot, dir = backward())[-1..] | u <- group} : {};
@@ -342,7 +342,7 @@ private list[ConversionUnit] addInnerRules(list[ConversionUnit] units) {
                     toRegExp(rsc, [\alt(ends)], {t}),
                     [toTmRule(toRegExp(rsc, [s], {t})) | s <- toTerminals(segs)])
                     [name = "/inner/multi/<intercalate(",", [u.name | u <- group])>"];
-                
+
                 rules = insertIn(rules, (u: r | u <- group));
             }
 
@@ -370,7 +370,7 @@ private list[ConversionUnit] addInnerRules(list[ConversionUnit] units) {
                             // and an `end` delimiter, then generate a
                             // begin/end pattern to highlight these delimiters
                             // and all content in between.
-                            
+
                             set[Segment] segs = getSegments(rsc, suffix);
                             segs = {removeBeginEnd(seg, {begin}, {end}) | seg <- segs};
 
@@ -379,7 +379,7 @@ private list[ConversionUnit] addInnerRules(list[ConversionUnit] units) {
                                 toRegExp(rsc, [end], {t}),
                                 [toTmRule(toRegExp(rsc, [s], {t})) | s <- toTerminals(segs)]);
                         }
-                        
+
                         else {
                             // If the suffix has a `begin` delimiter, but not
                             // an `end` delimiter, then generate a match pattern
@@ -475,7 +475,7 @@ private list[ConversionUnit] addOuterRules(list[ConversionUnit] units) {
                 toRegExp(rsc, [\alt(ends)], {}),
                 [include("#<r.name>") | TmRule r <- innerRules])
                 [name = "/outer/<begin.string>"];
-            
+
             rules = insertIn(rules, (u: r | u <- group));
         }
     }