New dircat for files

Author: j-woz

stc/code/src/exm/stc/common/lang/Operators.java

@@ -159,6 +159,22 @@ private static void fillArithOps() {
       }
     }
 
+    /*
+     * Allow the directory catenation operator (/) to take file operands as
+     * well as strings: a file contributes its filename.  The result is
+     * always a string.  The frontend replaces each file operand with its
+     * filename future, so the underlying DIRCAT op still sees only strings.
+     */
+    OpInputType dircatFile = new OpInputType(Types.F_FILE, false);
+    OpInputType dircatString = new OpInputType(Types.F_STRING, false);
+    for (List<OpInputType> dircatArgs:
+         Arrays.asList(Arrays.asList(dircatFile, dircatString),
+                       Arrays.asList(dircatString, dircatFile),
+                       Arrays.asList(dircatFile, dircatFile))) {
+      registerOverload(ExMParser.DIV, BuiltinOpcode.DIRCAT,
+                       new OpType(Types.F_STRING, dircatArgs));
+    }
+
     Type sprintfArg = UnionType.createUnionType(Types.F_STRING, Types.F_INT, Types.F_FLOAT, Types.F_BOOL);
     List<OpInputType> sprintfArgs = Arrays.asList(new OpInputType(Types.F_STRING, false),
                                                   new OpInputType(sprintfArg, true));
@@ -176,6 +192,15 @@ private static void registerOperator(int token, BuiltinOpcode opCode,
     arithOps.put(token, new Op(opCode, opType));
   }
 
+  /**
+   * Register an extra overload for an operator, leaving the canonical type
+   * recorded for the opcode alone.
+   */
+  private static void registerOverload(int token, BuiltinOpcode opCode,
+                                       OpType opType) {
+    arithOps.put(token, new Op(opCode, opType));
+  }
+
   private static String getOpTypeName(PrimType numType) {
     switch (numType) {
     case BOOL:

stc/code/src/exm/stc/frontend/ExprWalker.java

@@ -599,12 +599,31 @@ private void callOperator(Context context, SwiftAST tree,
       } else {
         // Store into temporary variables
         Var arg = eval(context, tree.child(i + 1), exprType, false, renames);
+        if (Types.isFile(arg)) {
+          // Operators work on strings: a file operand contributes its
+          // filename.  Used by the directory catenation operator (/).
+          arg = filenameOf(context, arg);
+        }
         iList.add(Arg.newVar(arg));
       }
     }
     asyncOp(op.code, out, iList);
   }
 
+  /**
+   * Get a string future aliasing the filename of a file variable.
+   * @param context
+   * @param fileVar a file
+   * @return string future holding the filename
+   */
+  private Var filenameOf(Context context, Var fileVar)
+      throws UserException, UndefinedTypeException {
+    Var filename = varCreator.createFilenameAlias(context, fileVar);
+    backend.getFileNameAlias(VarRepr.backendVar(filename),
+                             VarRepr.backendVar(fileVar), false);
+    return filename;
+  }
+
 
   /**
    * Evaluate a tuple expression.

stc/code/src/exm/stc/frontend/VariableUsageAnalyzer.java

@@ -715,8 +715,15 @@ private void walkExpr(Context context, VariableUsageInfo vu,
         case ExMParser.OPERATOR:
           // Walk argument expressions
           // skip the first child, which is the operator name
+          boolean dircat = node.child(0).getType() == ExMParser.DIV;
           for (int i = 1; i < node.getChildCount(); i++) {
-            exprNodes.push(node.child(i));
+            SwiftAST arg = node.child(i);
+            if (dircat && filenameOnlyUse(vu, arg)) {
+              // Directory catenation uses only a file's name, not its
+              // contents, so the file need not be written
+              continue;
+            }
+            exprNodes.push(arg);
           }
           break;
         case ExMParser.ARRAY_RANGE:
@@ -786,6 +793,22 @@ private void walkExpr(Context context, VariableUsageInfo vu,
   }
 
 
+  /**
+   * Check whether an operand is a plain file variable.  The directory
+   * catenation operator (/) uses such an operand only for its filename, so
+   * it does not count as a read of the file's contents.
+   * @param vu variable usage info for the enclosing scope
+   * @param arg operand expression
+   */
+  private boolean filenameOnlyUse(VariableUsageInfo vu, SwiftAST arg) {
+    if (arg.getType() != ExMParser.VARIABLE) {
+      return false;
+    }
+    VariableUsageInfo.VInfo vi =
+        vu.lookupVariableInfo(arg.child(0).getText());
+    return vi != null && Types.isFile(vi.getType());
+  }
+
   private void walkTopLevelModule(Context fnContext, ParsedModule module,
       VariableUsageInfo topLevelVui, Set<ParsedModule> visited)
       throws UserException {

stc/tests/676-dircat-file.exp

@@ -0,0 +1 @@
+trace: dir_676/file.txt,dir_676/sub,top/leaf.txt,dir_676/leaf.txt

stc/tests/676-dircat-file.swift

@@ -0,0 +1,10 @@
+
+// Tests the directory catenation operator (/) applied to files.
+// A file operand contributes its filename; the result is a string.
+
+file d<"dir_676">;
+file f<"leaf.txt">;
+s = "sub";
+
+// file/string, file/string, string/file, file/file
+trace(d/"file.txt", d/s, "top"/f, d/f);