Optimizing captures in Scope

Src/AST/Myc.Ast.Scope.pas

@@ -11,18 +11,28 @@ uses
 
 type
     TExecutionScope = class(TInterfacedObject, IExecutionScope)
+        type
+            TValueCell = class(TInterfacedObject, IValueCell)
+            private
+                FValue: TDataValue;
+                function GetValue: TDataValue; inline;
+                procedure SetValue(const AValue: TDataValue); inline;
+            public
+                constructor Create(const AValue: TDataValue);
+            end;
+
     private
         FParent: IExecutionScope;
         FDescriptor: IScopeDescriptor;
-        FValues: TArray<IValueCell>;
-        // Stores references to the value cells captured by a closure.
+        FValues: TArray<TDataValue>;
         FCapturedUpvalues: TArray<IValueCell>;
         FNameToIndex: TDictionary<string, Integer>;
         procedure DumpScope(const ABuilder: TStringBuilder; AIndent: Integer);
         procedure NeedNameToIndex;
         function GetParent: IExecutionScope;
-        function GetCell(const Address: TResolvedAddress): IValueCell;
         function GetNameToIndex: TDictionary<string, Integer>;
+        function GetValues(const Address: TResolvedAddress): TDataValue;
+        procedure SetValues(const Address: TResolvedAddress; const Value: TDataValue);
     public
         constructor Create(
             AParent: IExecutionScope = nil;
@@ -33,9 +43,9 @@ type
         procedure Clear;
         function Dump: string;
         procedure Define(const Name: string; const Value: TDataValue);
+        function Capture(const Address: TResolvedAddress): IValueCell;
         property NameToIndex: TDictionary<string, Integer> read GetNameToIndex;
         property Parent: IExecutionScope read FParent;
-        property Values: TArray<IValueCell> read FValues;
     end;
 
 implementation
@@ -43,22 +53,20 @@ implementation
 uses
     System.Generics.Defaults;
 
-type
-    TValueCell = class(TInterfacedObject, IValueCell)
-    private
-        FValue: TDataValue;
-        function GetValue: TDataValue;
-        procedure SetValue(const AValue: TDataValue);
-    end;
-
 { TValueCell }
 
-function TValueCell.GetValue: TDataValue;
+constructor TExecutionScope.TValueCell.Create(const AValue: TDataValue);
+begin
+    inherited Create;
+    FValue := AValue;
+end;
+
+function TExecutionScope.TValueCell.GetValue: TDataValue;
 begin
     Result := FValue;
 end;
 
-procedure TValueCell.SetValue(const AValue: TDataValue);
+procedure TExecutionScope.TValueCell.SetValue(const AValue: TDataValue);
 begin
     FValue := AValue;
 end;
@@ -84,8 +92,6 @@ begin
     begin
         slotCount := ADescriptor.SlotCount;
         SetLength(FValues, slotCount);
-        for i := 0 to slotCount - 1 do
-            FValues[i] := TValueCell.Create as IValueCell;
     end;
 end;
 
@@ -95,7 +101,18 @@ begin
     inherited Destroy;
 end;
 
-function TExecutionScope.GetCell(const Address: TResolvedAddress): IValueCell;
+function TExecutionScope.GetParent: IExecutionScope;
+begin
+    Result := FParent;
+end;
+
+procedure TExecutionScope.Clear;
+begin
+    FValues := [];
+    FreeAndNil(FNameToIndex);
+end;
+
+function TExecutionScope.Capture(const Address: TResolvedAddress): IValueCell;
 begin
     case Address.Kind of
         akUpvalue:
@@ -116,27 +133,16 @@ begin
                 Assert(Assigned(targetScope), 'Invalid scope depth during value retrieval.');
             end;
             Assert(
-                (Address.SlotIndex >= 0) and (Address.SlotIndex < Length(targetScope.Values)),
+                (Address.SlotIndex >= 0) and (Address.SlotIndex < Length(targetScope.FValues)),
                 'Invalid scope index during value retrieval.'
             );
-            Result := targetScope.Values[Address.SlotIndex];
+            Result := TValueCell.Create(targetScope.FValues[Address.SlotIndex]);
         end;
     else
         raise EInvalidOpException.Create('Cannot get value for an unresolved address.');
     end;
 end;
 
-function TExecutionScope.GetParent: IExecutionScope;
-begin
-    Result := FParent;
-end;
-
-procedure TExecutionScope.Clear;
-begin
-    FValues := [];
-    FreeAndNil(FNameToIndex);
-end;
-
 procedure TExecutionScope.Define(const Name: string; const Value: TDataValue);
 var
     index: Integer;
@@ -148,8 +154,7 @@ begin
 
     index := Length(FValues);
     SetLength(FValues, index + 1);
-    FValues[index] := TValueCell.Create as IValueCell;
-    FValues[index].Value := Value;
+    FValues[index] := Value;
     FNameToIndex.Add(Name, index);
 end;
 
@@ -173,7 +178,7 @@ begin
 
         for pair in sortedPairs do
             // Access the value inside the cell for printing.
-            ABuilder.AppendLine(indentStr + Format('  [%d] %s: %s', [pair.Value, pair.Key, FValues[pair.Value].Value.ToString]));
+            ABuilder.AppendLine(indentStr + Format('  [%d] %s: %s', [pair.Value, pair.Key, FValues[pair.Value].ToString]));
     end
     else
     begin
@@ -207,6 +212,37 @@ begin
     Result := FNameToIndex;
 end;
 
+function TExecutionScope.GetValues(const Address: TResolvedAddress): TDataValue;
+begin
+    case Address.Kind of
+        akUpvalue:
+        begin
+            Assert(Assigned(FCapturedUpvalues), 'Attempt to access an upvalue in a scope with no closure context.');
+            Assert(
+                (Address.SlotIndex >= 0) and (Address.SlotIndex < Length(FCapturedUpvalues)),
+                'Invalid upvalue index during value retrieval.'
+            );
+            Result := FCapturedUpvalues[Address.SlotIndex].Value;
+        end;
+        akLocalOrParent:
+        begin
+            var targetScope := Self;
+            for var i := 1 to Address.ScopeDepth do
+            begin
+                targetScope := targetScope.Parent as TExecutionScope;
+                Assert(Assigned(targetScope), 'Invalid scope depth during value retrieval.');
+            end;
+            Assert(
+                (Address.SlotIndex >= 0) and (Address.SlotIndex < Length(targetScope.FValues)),
+                'Invalid scope index during value retrieval.'
+            );
+            Result := targetScope.FValues[Address.SlotIndex];
+        end;
+    else
+        raise EInvalidOpException.Create('Cannot get value for an unresolved address.');
+    end;
+end;
+
 procedure TExecutionScope.NeedNameToIndex;
 begin
     if FNameToIndex = nil then
@@ -220,4 +256,35 @@ begin
     end;
 end;
 
+procedure TExecutionScope.SetValues(const Address: TResolvedAddress; const Value: TDataValue);
+begin
+    case Address.Kind of
+        akUpvalue:
+        begin
+            Assert(Assigned(FCapturedUpvalues), 'Attempt to access an upvalue in a scope with no closure context.');
+            Assert(
+                (Address.SlotIndex >= 0) and (Address.SlotIndex < Length(FCapturedUpvalues)),
+                'Invalid upvalue index during value retrieval.'
+            );
+            FCapturedUpvalues[Address.SlotIndex].Value := Value;
+        end;
+        akLocalOrParent:
+        begin
+            var targetScope := Self;
+            for var i := 1 to Address.ScopeDepth do
+            begin
+                targetScope := targetScope.Parent as TExecutionScope;
+                Assert(Assigned(targetScope), 'Invalid scope depth during value retrieval.');
+            end;
+            Assert(
+                (Address.SlotIndex >= 0) and (Address.SlotIndex < Length(targetScope.FValues)),
+                'Invalid scope index during value retrieval.'
+            );
+            targetScope.FValues[Address.SlotIndex] := Value;
+        end;
+    else
+        raise EInvalidOpException.Create('Cannot get value for an unresolved address.');
+    end;
+end;
+
 end.