Fix trying to infer type for $ within slicing and indexing

Author: IDONTUSEGH

compiler/src/dmd/dcast.d

@@ -3340,6 +3340,12 @@ Expression inferType(Expression e, Type t, int flag = 0)
                 die.e1 = inferType(die.e1, t, flag);
             }
         }
+        else if (die.e1.op == EXP.call || die.e1.op == EXP.dotIdentifier)
+        {
+            // Handle chained expressions like $.a(10).b(20) or $.a.b.c
+            // Recursively infer type for the left side
+            die.e1 = inferType(die.e1, t, flag);
+        }
         return die;
     }
 
@@ -3353,6 +3359,11 @@ Expression inferType(Expression e, Type t, int flag = 0)
                 ce.e1 = inferType(ce.e1, t, flag);
             }
         }
+        else if (ce.e1.op == EXP.call || ce.e1.op == EXP.dotIdentifier)
+        {
+            // Handle chained calls like $.a(10)(20) or $.a.b(20)
+            ce.e1 = inferType(ce.e1, t, flag);
+        }
         return ce;
     }
 

compiler/src/dmd/dsymbolsem.d

@@ -2347,8 +2347,8 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
                 }
                 else
                 {
-                .error(dsym.loc, "%s `%s` - type `%s` is inferred from initializer `%s`, and variables cannot be of type `void`",
-                    dsym.kind, dsym.toPrettyChars, dsym.type.toChars(), toChars(dsym._init));
+                    .error(dsym.loc, "%s `%s` - type `%s` is inferred from initializer `%s`, and variables cannot be of type `void`",
+                        dsym.kind, dsym.toPrettyChars, dsym.type.toChars(), toChars(dsym._init));
                 }
             }
             else

compiler/src/dmd/expressionsem.d

@@ -5401,6 +5401,12 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
             return;
         }
 
+        if (sc.scopesym && sc.scopesym.isArrayScopeSymbol())
+        {
+            visit(cast(IdentifierExp)exp);
+            return;
+        }
+
         // if not found, it's $ waiting for type inference via implicitCastTo
         exp.type = Type.tvoid;
         result = exp;
@@ -15662,6 +15668,22 @@ private Expression expressionSemanticWithParent(Expression e, Scope* sc, Express
     return v.result;
 }
 
+/******
+ * Check if an expression contains a DollarExp (for chained $ inference)
+ */
+private bool containsDollarExp(Expression e)
+{
+    if (!e)
+        return false;
+    if (e.isDollarExp())
+        return true;
+    if (auto ce = e.isCallExp())
+        return containsDollarExp(ce.e1);
+    if (auto die = e.isDotIdExp())
+        return containsDollarExp(die.e1);
+    return false;
+}
+
 private Expression dotIdSemanticPropX(DotIdExp exp, Scope* sc)
 {
     //printf("dotIdSemanticPropX() %s\n", toChars(exp));
@@ -15670,7 +15692,7 @@ private Expression dotIdSemanticPropX(DotIdExp exp, Scope* sc)
 
     if (exp.e1.type == Type.tvoid)
     {
-        if (exp.e1.isDollarExp())
+        if (exp.e1.isDollarExp() || containsDollarExp(exp.e1))
         {
             auto n = new DotIdExp(exp.loc, exp.e1, exp.ident);
             n.type = Type.tvoid;

compiler/test/runnable/dollarinfer.d

@@ -1,3 +1,9 @@
+struct HasSlicing {
+    int[] data;
+    auto opSlice(size_t i, size_t j) { return data[i .. j]; }
+    @property size_t opDollar() { return data.length; }
+}
+
 enum MyEnum { VALUE_A, VALUE_B, VALUE_C }
 
 struct Data {
@@ -46,4 +52,9 @@ void main() {
     assert(slice[0] == 20);
 
     assert(slice[$ - 1] == 50);
+
+    HasSlicing t;
+    t.data = [1, 2, 3, 4, 5];
+    auto x = t[0 .. $];
+    assert(x.length == 5);
 }