rip-lang 3.17.1 → 3.17.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "3.17.1",
+  "version": "3.17.2",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",

package/scripts/serve.js

@@ -27,6 +27,30 @@ const MIME_TYPES = {
   '.rip': 'text/plain; charset=utf-8'
 };
 
+// ETag (size+mtime, plus encoding so brotli/plain get distinct tags) +
+// no-cache for cheap 304 revalidation, and Vary so caches don't mix encodings.
+// Returns null if unreadable, letting the caller fall back.
+function serveFile(req, diskPath, contentType, encoding) {
+  let stat;
+  try { stat = statSync(diskPath); } catch { return null; }
+  const etag = `"${stat.size.toString(16)}-${Math.round(stat.mtimeMs).toString(16)}${encoding ? '-' + encoding : ''}"`;
+  const headers = {
+    'Content-Type': contentType,
+    'ETag': etag,
+    'Cache-Control': 'no-cache',
+    'Vary': 'Accept-Encoding'
+  };
+  if (encoding) headers['Content-Encoding'] = encoding;
+  if (req.headers.get('if-none-match') === etag) {
+    return new Response(null, { status: 304, headers });
+  }
+  try {
+    return new Response(readFileSync(diskPath), { headers });
+  } catch {
+    return null;
+  }
+}
+
 // Request handler for serving files
 function handleRequest(req) {
   const url = new URL(req.url);
@@ -50,34 +74,19 @@ function handleRequest(req) {
   const filePath = join(ROOT, pathname);
   const ext = extname(pathname);
   const acceptEncoding = req.headers.get('accept-encoding') || '';
+  const contentType = MIME_TYPES[ext] || 'application/octet-stream';
 
-  // Check for brotli compressed version (.br)
+  // Prefer the pre-compressed Brotli sidecar when the client accepts it.
   if (acceptEncoding.includes('br') && existsSync(filePath + '.br')) {
-    try {
-      const compressed = readFileSync(filePath + '.br');
-      return new Response(compressed, {
-        headers: {
-          'Content-Type': MIME_TYPES[ext] || 'application/octet-stream',
-          'Content-Encoding': 'br',
-          'Cache-Control': 'no-cache'
-        }
-      });
-    } catch (e) {
-      // Fall through to regular file
-    }
+    const res = serveFile(req, filePath + '.br', contentType, 'br');
+    if (res) return res;
   }
 
-  // Serve regular file
-  try {
-    const file = readFileSync(filePath);
-    return new Response(file, {
-      headers: {
-        'Content-Type': MIME_TYPES[ext] || 'application/octet-stream'
-      }
-    });
-  } catch (e) {
-    return new Response('404 Not Found', { status: 404 });
-  }
+  // Plain file — also the failover when no .br sidecar exists.
+  const res = serveFile(req, filePath, contentType, null);
+  if (res) return res;
+
+  return new Response('404 Not Found', { status: 404 });
 }
 
 // Try to start server on preferred port, fallback to OS-assigned port

package/src/types.js

@@ -405,12 +405,23 @@ function looksLikeBareFunctionType(typeTokens) {
 // left alone and any side effects survive.
 function isCompleteTypeExpr(tokens, a, b) {
   if (b <= a) return false;
-  const SEP = new Set(['|', '&', ',', ':', '?', '.', '...', '=>']);
+  const SEP = new Set(['|', '&', ',', ':', '?', '.', '...']);
   let par = 0, brk = 0, brc = 0, gen = 0, atomEnd = false;
+  const parInfo = [];          // per-paren-depth: { colon, open }
+  let lastClosedParen = null;  // { colon, empty } of the most recently closed group
   for (let j = a; j < b; j++) {
     const t = tokens[j][0], v = tokens[j][1];
-    if (t === '(' || t === 'PARAM_START')      { par++; atomEnd = false; continue; }
-    if (t === ')' || t === 'PARAM_END')        { if (--par < 0) return false; atomEnd = true; continue; }
+    // Function-type arrow: valid only after a closed param group that is empty
+    // `()` or typed `(x: T)`. An untyped `(e) =>` (or leading `=>`) is a value
+    // arrow, so context B won't misread `@input: (e) => x = y` as a typed decl.
+    if (t === '=>') {
+      const p = j > a ? tokens[j - 1][0] : null;
+      if ((p === ')' || p === 'PARAM_END') && lastClosedParen &&
+          (lastClosedParen.colon || lastClosedParen.empty)) { atomEnd = false; continue; }
+      return false;
+    }
+    if (t === '(' || t === 'PARAM_START')      { parInfo.push({ colon: false, open: j }); par++; atomEnd = false; continue; }
+    if (t === ')' || t === 'PARAM_END')        { if (--par < 0) return false; const pi = parInfo.pop(); lastClosedParen = pi ? { colon: pi.colon, empty: j === pi.open + 1 } : null; atomEnd = true; continue; }
     if (t === '[' || t === 'INDEX_START')      { brk++; atomEnd = false; continue; }
     if (t === ']' || t === 'INDEX_END')        { if (--brk < 0) return false; atomEnd = true; continue; }
     if (t === '{')                             { brc++; atomEnd = false; continue; }
@@ -425,7 +436,7 @@ function isCompleteTypeExpr(tokens, a, b) {
       return false;
     }
     if (t === '=') { if (gen > 0) { atomEnd = false; continue; } return false; } // generic default only
-    if (SEP.has(t)) { atomEnd = false; continue; }
+    if (SEP.has(t)) { if (t === ':' && parInfo.length) parInfo[parInfo.length - 1].colon = true; atomEnd = false; continue; }
     if (t === 'IDENTIFIER' || t === 'PROPERTY' || t === 'NUMBER' ||
         t === 'STRING' || t === 'NULL' || t === 'UNDEFINED' || t === 'BOOL') {
       if (atomEnd) return false;               // two atoms, no separator → not a type