Implement as syntax for multiple base types (mob|obj|turf)

DMCompiler/Bytecode/DreamProcOpcode.cs

@@ -137,7 +137,8 @@ public enum DreamProcOpcode : byte {
     CreateFilteredListEnumerator = 0x41,
     [OpcodeMetadata(-1)]
     Power = 0x42,
-    //0x43,
+    [OpcodeMetadata(-1, OpcodeArgType.EnumeratorId, OpcodeArgType.FilterId)]
+    CreateFilteredBaseTypesListEnumerator = 0x43,
     //0x44
     [OpcodeMetadata(-3, OpcodeArgType.TypeId)]
     Prompt = 0x45,

DMCompiler/DM/Builders/DMProcBuilder.cs

@@ -612,8 +612,10 @@ public void ProcessStatementForList(DMExpression list, DMExpression outputVar, D
                 implicitTypeCheck = dmTypes.Value.TypePath;
             } else if (!dmTypes.Value.IsAnything) {
                 // "as anything" performs no check. Other values are unimplemented.
-                DMCompiler.UnimplementedWarning(outputVar.Location,
-                    $"As type {dmTypes} in for loops is unimplemented. No type check will be performed.");
+                byte typeId = (byte) dmTypes.Value.Type;
+                proc.CreateFilteredBaseTypesListEnumerator(typeId, dmTypes.Value.Type);
+                // DMCompiler.UnimplementedWarning(outputVar.Location,
+                //     $"As type {dmTypes} in for loops is unimplemented. No type check will be performed.");
             }
 
             list.EmitPushValue(dmObject, proc);

DMCompiler/DM/DMProc.cs

@@ -372,6 +372,12 @@ public void CreateFilteredListEnumerator(int filterTypeId, DreamPath filterType)
             WriteFilterID(filterTypeId, filterType);
         }
 
+        public void CreateFilteredBaseTypesListEnumerator(byte filterTypeId, DMValueType filterType) {
+            WriteOpcode(DreamProcOpcode.CreateFilteredBaseTypesListEnumerator);
+            WriteEnumeratorId(_enumeratorIdCounter++);
+            WriteFilterTypeID(filterTypeId, filterType);
+        }
+
         public void CreateTypeEnumerator() {
             WriteOpcode(DreamProcOpcode.CreateTypeEnumerator);
             WriteEnumeratorId(_enumeratorIdCounter++);
@@ -1115,6 +1121,10 @@ private void WriteFilterID(int filterId, DreamPath filter) {
             AnnotatedBytecode.WriteFilterId(filterId, filter, _writerLocation);
         }
 
+        private void WriteFilterTypeID(byte filterId, DMValueType filter) {
+            AnnotatedBytecode.WriteFilterTypeId(filterId, filter, _writerLocation);
+        }
+
         private void WriteStackDelta(int delta) {
             AnnotatedBytecode.WriteStackDelta(delta, _writerLocation);
         }

DMCompiler/Optimizer/AnnotatedByteCodeWriter.cs

@@ -152,6 +152,25 @@ public void WriteFilterId(int filterTypeId, DreamPath filterPath, Location locat
         _annotatedBytecode[^1].AddArg(new AnnotatedBytecodeFilter(filterTypeId, filterPath, location));
     }
 
+    /// <summary>
+    /// Write a filter. Filters are stored as reference IDs in the raw bytecode, which refer
+    /// to a string in the string table containing the datum path of the filter.
+    /// </summary>
+    /// <param name="filterPaths">The datum paths of the filter</param>
+    /// <param name="location">The location of the filter in the source code</param>
+    ///
+    public void WriteFilterTypeId(byte filterTypeId, DMValueType filterPaths, Location location) {
+        _location = location;
+
+        if (_requiredArgs.Count == 0 || _requiredArgs.Peek() != OpcodeArgType.FilterId) {
+            DMCompiler.ForcedError(location, "Expected filter argument");
+        }
+
+        _requiredArgs.Pop();
+
+        _annotatedBytecode[^1].AddArg(new AnnotatedBytecodeTypeFilter(filterTypeId, filterPaths, location));
+    }
+
     /// <summary>
     /// Write a list size, restricted to non-negative integers
     /// </summary>

DMCompiler/Optimizer/AnnotatedBytecode.cs

@@ -574,6 +574,35 @@ public Location GetLocation() {
     }
 }
 
+internal sealed class AnnotatedBytecodeTypeFilter : IAnnotatedBytecode {
+    public DMValueType FilterPath;
+
+    public int FilterTypeId;
+    public Location Location;
+
+    public AnnotatedBytecodeTypeFilter(int filterTypeId, DMValueType filterPath, Location location) {
+        FilterTypeId = filterTypeId;
+        FilterPath = filterPath;
+        Location = location;
+    }
+
+    public void AddArg(IAnnotatedBytecode arg) {
+        DMCompiler.ForcedError(Location, "Cannot add args to a filter");
+    }
+
+    public void SetLocation(IAnnotatedBytecode loc) {
+        Location = loc.GetLocation();
+    }
+
+    public void SetLocation(Location loc) {
+        Location = loc;
+    }
+
+    public Location GetLocation() {
+        return Location;
+    }
+}
+
 internal sealed class AnnotatedBytecodeReference : IAnnotatedBytecode {
     public int Index;
     public Location Location;

OpenDreamRuntime/Procs/DMOpcodeHandlers.cs

@@ -125,6 +125,16 @@ public static ProcStatus CreateFilteredListEnumerator(DMProcState state) {
             return ProcStatus.Continue;
         }
 
+        public static ProcStatus CreateFilteredBaseTypesListEnumerator(DMProcState state) { // this is also plagarized from the above. make sure thats ok? and remove this comment
+            var enumeratorId = state.ReadInt();
+            var filterTypeId = state.ReadInt();
+            var filterType = state.Proc.ObjectTree.GetTreeEntry(filterTypeId); // this REALLY probably has to change. seems to be a path rn
+            var enumerator = GetContentsEnumerator(state.Proc.ObjectTree, state.Proc.AtomManager, state.Pop(), filterType);
+
+            state.Enumerators[enumeratorId] = enumerator;
+            return ProcStatus.Continue;
+        }
+
         public static ProcStatus CreateTypeEnumerator(DMProcState state) {
             var enumeratorId = state.ReadInt();
             var typeValue = state.Pop();

OpenDreamRuntime/Procs/DMProc.cs

@@ -242,6 +242,7 @@ public sealed class DMProcState : ProcState {
             {DreamProcOpcode.OutputControl, DMOpcodeHandlers.OutputControl},
             {DreamProcOpcode.BitShiftRight, DMOpcodeHandlers.BitShiftRight},
             {DreamProcOpcode.CreateFilteredListEnumerator, DMOpcodeHandlers.CreateFilteredListEnumerator},
+            {DreamProcOpcode.CreateFilteredBaseTypesListEnumerator, DMOpcodeHandlers.CreateFilteredBaseTypesListEnumerator},
             {DreamProcOpcode.Power, DMOpcodeHandlers.Power},
             {DreamProcOpcode.Prompt, DMOpcodeHandlers.Prompt},
             {DreamProcOpcode.Ftp, DMOpcodeHandlers.Ftp},

OpenDreamRuntime/Procs/ProcDecoder.cs

@@ -162,6 +162,7 @@ public ITuple DecodeInstruction() {
                 return (opcode, ReadInt(), ReadReference(), ReadInt());
 
             case DreamProcOpcode.CreateFilteredListEnumerator:
+            case DreamProcOpcode.CreateFilteredBaseTypesListEnumerator:
             case DreamProcOpcode.EnumerateNoAssign:
                 return (opcode, ReadInt(), ReadInt());
 
@@ -289,6 +290,12 @@ or DreamProcOpcode.JumpIfTrueReference
                 text.Append(getTypePath(type));
                 break;
 
+            case (DreamProcOpcode.CreateFilteredBaseTypesListEnumerator, int enumeratorId, int type):
+                text.Append(enumeratorId);
+                text.Append(' ');
+                text.Append(getTypePath(type)); // TODO: maybe make sure this works / leave as thing for reviewer to talk abt
+                break;
+
             case (DreamProcOpcode.CreateListNRefs
                     or DreamProcOpcode.PushNRefs, DMReference[] refs): {
                 foreach (var reference in refs) {