fcl-passrc: started transition TPasElement reference counting to Parent free

packages/fcl-passrc/src/pasresolveeval.pas

@@ -1540,7 +1540,7 @@ begin
   Result:=nil;
   if (Expr.Kind=pekBinary) and (Expr.OpCode=eopSubIdent) then
     begin
-    Result:=Eval(Expr.right,Flags);
+    Result:=Eval(Expr.Right,Flags);
     exit;
     end;
   LeftValue:=nil;
@@ -1549,24 +1549,24 @@ begin
     if Expr.OpCode=eopAdd then
       begin
       // handle multi adds without stack
-      Left:=Expr.left;
+      Left:=Expr.Left;
       while Left.ClassType=TBinaryExpr do
         begin
         SubBin:=TBinaryExpr(Left);
         if SubBin.OpCode<>eopAdd then break;
-        Left:=SubBin.left;
+        Left:=SubBin.Left;
         end;
       LeftValue:=Eval(Left,Flags);
       while LeftValue<>nil do
         begin
         SubBin:=TBinaryExpr(Left.Parent);
-        RightValue:=Eval(SubBin.right,Flags);
+        RightValue:=Eval(SubBin.Right,Flags);
         if RightValue=nil then exit;
 
         if LeftValue.Kind=revkExternal then
           begin
           if [refConst,refConstExt]*Flags=[refConst] then
-            RaiseConstantExprExp(20210321205928,Expr.left);
+            RaiseConstantExprExp(20210321205928,Expr.Left);
           Result:=LeftValue;
           LeftValue:=nil;
           exit;
@@ -1574,7 +1574,7 @@ begin
         if RightValue.Kind=revkExternal then
           begin
           if [refConst,refConstExt]*Flags=[refConst] then
-            RaiseConstantExprExp(20210321205948,Expr.right);
+            RaiseConstantExprExp(20210321205948,Expr.Right);
           Result:=RightValue;
           RightValue:=nil;
           exit;
@@ -1592,15 +1592,15 @@ begin
       exit;
       end;
 
-    LeftValue:=Eval(Expr.left,Flags);
+    LeftValue:=Eval(Expr.Left,Flags);
     if LeftValue=nil then exit;
-    RightValue:=Eval(Expr.right,Flags);
+    RightValue:=Eval(Expr.Right,Flags);
     if RightValue=nil then exit;
 
     if LeftValue.Kind=revkExternal then
       begin
       if [refConst,refConstExt]*Flags=[refConst] then
-        RaiseConstantExprExp(20181024134508,Expr.left);
+        RaiseConstantExprExp(20181024134508,Expr.Left);
       Result:=LeftValue;
       LeftValue:=nil;
       exit;
@@ -1608,7 +1608,7 @@ begin
     if RightValue.Kind=revkExternal then
       begin
       if [refConst,refConstExt]*Flags=[refConst] then
-        RaiseConstantExprExp(20181024134545,Expr.right);
+        RaiseConstantExprExp(20181024134545,Expr.Right);
       Result:=RightValue;
       RightValue:=nil;
       exit;
@@ -1784,10 +1784,10 @@ begin
   {$endif}
   revkUnicodeString:
     begin
-    LeftInt:=StringToOrd(LeftValue,Expr.left);
+    LeftInt:=StringToOrd(LeftValue,Expr.Left);
     if RightValue.Kind in revkAllStrings then
       begin
-      RightInt:=StringToOrd(RightValue,Expr.right);
+      RightInt:=StringToOrd(RightValue,Expr.Right);
       if LeftInt>RightInt then
         RaiseMsg(20170523151508,nHighRangeLimitLTLowRangeLimit,
           sHighRangeLimitLTLowRangeLimit,[],Expr.Right);
@@ -1932,7 +1932,7 @@ begin
     revkString,
     {$endif}
     revkUnicodeString:
-      Result:=EvalStringAddExpr(Expr,Expr.left,Expr.right,LeftValue,RightValue);
+      Result:=EvalStringAddExpr(Expr,Expr.Left,Expr.Right,LeftValue,RightValue);
     revkSetOfInt:
       case RightValue.Kind of
       revkSetOfInt:
@@ -3125,10 +3125,10 @@ begin
         if GetCodePage(TResEvalString(LeftValue).S)=GetCodePage(TResEvalString(RightValue).S) then
           TResEvalBool(Result).B:=TResEvalString(LeftValue).S=TResEvalString(RightValue).S
         else
-          TResEvalBool(Result).B:=GetUnicodeStr(TResEvalString(LeftValue).S,Expr.left)
-                                 =GetUnicodeStr(TResEvalString(RightValue).S,Expr.right);
+          TResEvalBool(Result).B:=GetUnicodeStr(TResEvalString(LeftValue).S,Expr.Left)
+                                 =GetUnicodeStr(TResEvalString(RightValue).S,Expr.Right);
       revkUnicodeString:
-        TResEvalBool(Result).B:=GetUnicodeStr(TResEvalString(LeftValue).S,Expr.left)
+        TResEvalBool(Result).B:=GetUnicodeStr(TResEvalString(LeftValue).S,Expr.Left)
                                =TResEvalUTF16(RightValue).S;
       else
         {$IFDEF VerbosePasResolver}
@@ -3143,7 +3143,7 @@ begin
       {$ifdef FPC_HAS_CPSTRING}
       revkString:
         TResEvalBool(Result).B:=TResEvalUTF16(LeftValue).S
-                               =GetUnicodeStr(TResEvalString(RightValue).S,Expr.right);
+                               =GetUnicodeStr(TResEvalString(RightValue).S,Expr.Right);
       {$endif}
       revkUnicodeString:
         TResEvalBool(Result).B:=TResEvalUTF16(LeftValue).S
@@ -3459,10 +3459,10 @@ begin
             TResEvalBool(Result).B:=TResEvalString(LeftValue).S >= TResEvalString(RightValue).S;
           end
         else
-          CmpUnicode(GetUnicodeStr(TResEvalString(LeftValue).S,Expr.left),
-                     GetUnicodeStr(TResEvalString(RightValue).S,Expr.right));
+          CmpUnicode(GetUnicodeStr(TResEvalString(LeftValue).S,Expr.Left),
+                     GetUnicodeStr(TResEvalString(RightValue).S,Expr.Right));
       revkUnicodeString:
-        CmpUnicode(GetUnicodeStr(TResEvalString(LeftValue).S,Expr.left),
+        CmpUnicode(GetUnicodeStr(TResEvalString(LeftValue).S,Expr.Left),
                    TResEvalUTF16(RightValue).S);
       else
         {$IFDEF VerbosePasResolver}
@@ -3477,7 +3477,7 @@ begin
       {$ifdef FPC_HAS_CPSTRING}
       revkString:
         CmpUnicode(TResEvalUTF16(LeftValue).S,
-                   GetUnicodeStr(TResEvalString(RightValue).S,Expr.right));
+                   GetUnicodeStr(TResEvalString(RightValue).S,Expr.Right));
       {$endif}
       revkUnicodeString:
         CmpUnicode(TResEvalUTF16(LeftValue).S,TResEvalUTF16(RightValue).S);
@@ -5136,14 +5136,14 @@ begin
     Format2:=-1;
     try
       ValStr:='';
-      if Param.format1<>nil then
+      if Param.Format1<>nil then
         begin
-        Format1:=EvalFormat(Param.format1,1,255);
+        Format1:=EvalFormat(Param.Format1,1,255);
         if Format1<0 then
           continue;
-        if Param.format2<>nil then
+        if Param.Format2<>nil then
           begin
-          Format2:=EvalFormat(Param.format2,0,255);
+          Format2:=EvalFormat(Param.Format2,0,255);
           if Format2<0 then
             continue;
           end;

packages/fcl-passrc/src/pasresolver.pp

@@ -2535,9 +2535,9 @@ begin
     if El.ClassType=TUnaryExpr then
       Result:=Result+GetTreeDbg(TUnaryExpr(El).Operand,Indent)
     else if El.ClassType=TBinaryExpr then
-      Result:=Result+'Left={'+GetTreeDbg(TBinaryExpr(El).left,Indent)+'}'
+      Result:=Result+'Left={'+GetTreeDbg(TBinaryExpr(El).Left,Indent)+'}'
          +OpcodeStrings[TPasExpr(El).OpCode]
-         +'Right={'+GetTreeDbg(TBinaryExpr(El).right,Indent)+'}'
+         +'Right={'+GetTreeDbg(TBinaryExpr(El).Right,Indent)+'}'
     else if El.ClassType=TPrimitiveExpr then
       Result:=Result+TPrimitiveExpr(El).Value
     else if El.ClassType=TBoolConstExpr then
@@ -3099,9 +3099,9 @@ begin
     Bin:=TBinaryExpr(Expr);
     if Bin.OpCode=eopSubIdent then
       begin
-      Result:=DotExprToName(Bin.left);
+      Result:=DotExprToName(Bin.Left);
       if Result='' then exit;
-      s:=DotExprToName(Bin.right);
+      s:=DotExprToName(Bin.Right);
       if s='' then exit('');
       Result:=Result+'.'+s;
       end;
@@ -4677,11 +4677,11 @@ begin
     if not (El.Parent is TBinaryExpr) then exit;
     Bin:=TBinaryExpr(El.Parent);
     if Bin.OpCode<>eopSubIdent then exit;
-    if El=Bin.right then
+    if El=Bin.Right then
       El:=Bin
     else
       begin
-      El:=Bin.right;
+      El:=Bin.Right;
       // find left most
       repeat
         C:=El.ClassType;
@@ -4695,7 +4695,7 @@ begin
           begin
           if TBinaryExpr(El).OpCode<>eopSubIdent then
             RaiseNotYetImplemented(20170502163718,El);
-          El:=TBinaryExpr(El).left;
+          El:=TBinaryExpr(El).Left;
           end
         else if C=TParamsExpr then
           begin
@@ -4722,7 +4722,7 @@ begin
       begin
       if TBinaryExpr(Result).OpCode<>eopSubIdent then
         exit;
-      Result:=TBinaryExpr(Result).left;
+      Result:=TBinaryExpr(Result).Left;
       end
     else if C=TParamsExpr then
       begin
@@ -4748,7 +4748,7 @@ begin
       begin
       if TBinaryExpr(Result).OpCode<>eopSubIdent then
         exit;
-      Result:=TBinaryExpr(Result).right;
+      Result:=TBinaryExpr(Result).Right;
       end
     else
       exit;
@@ -4784,7 +4784,7 @@ begin
   if Parent.ClassType=TBinaryExpr then
     begin
     Bin:=TBinaryExpr(Parent);
-    if (Bin.OpCode<>eopSubIdent) or (Bin.right<>El) then
+    if (Bin.OpCode<>eopSubIdent) or (Bin.Right<>El) then
       exit;
     El:=Bin;
     Parent:=El.Parent;
@@ -4808,7 +4808,7 @@ begin
   if Parent is TBinaryExpr then
     begin
     if (TBinaryExpr(Parent).OpCode<>eopSubIdent)
-        or (TBinaryExpr(Parent).right<>El) then
+        or (TBinaryExpr(Parent).Right<>El) then
       exit;
     El:=TBinaryExpr(Parent); // continue
     Parent:=El.Parent;
@@ -4862,7 +4862,7 @@ begin
     else if C=TBinaryExpr then
       begin
       if TBinaryExpr(El).OpCode=eopSubIdent then
-        El:=TBinaryExpr(El).left
+        El:=TBinaryExpr(El).Left
       else
         exit;
       end
@@ -4890,7 +4890,7 @@ begin
     begin
     Bin:=TBinaryExpr(El);
     if Bin.OpCode=eopSubIdent then
-      El:=Bin.right
+      El:=Bin.Right
     else
       exit(nil);
     end;
@@ -4915,7 +4915,7 @@ begin
     if C=TBinaryExpr then
       begin
       if TBinaryExpr(El).OpCode=eopSubIdent then
-        El:=TBinaryExpr(El).right
+        El:=TBinaryExpr(El).Right
       else
         exit;
       end
@@ -6358,8 +6358,8 @@ var
   StartResolved, EndResolved: TPasResolverResult;
 begin
   RangeExpr:=El.RangeExpr;
-  ResolveExpr(RangeExpr.left,rraRead);
-  ResolveExpr(RangeExpr.right,rraRead);
+  ResolveExpr(RangeExpr.Left,rraRead);
+  ResolveExpr(RangeExpr.Right,rraRead);
   FinishConstRangeExpr(RangeExpr,StartResolved,EndResolved);
 end;
 
@@ -6370,8 +6370,8 @@ var
   RgValue: TResEvalValue;
   Left, Right: TPasExpr;
 begin
-  Left:=RangeExpr.left;
-  Right:=RangeExpr.right;
+  Left:=RangeExpr.Left;
+  Right:=RangeExpr.Right;
   {$IFDEF VerbosePasResEval}
   writeln('TPasResolver.FinishConstRangeExpr Left=',GetObjName(Left),' Right=',GetObjName(Right));
   {$ENDIF}
@@ -9111,7 +9111,7 @@ begin
     if NameExpr is TBinaryExpr then
       begin
       Bin:=TBinaryExpr(NameExpr);
-      ResolveExpr(Bin.left,rraRead);
+      ResolveExpr(Bin.Left,rraRead);
       ComputeElement(Bin.Left,LeftResolved,[rcType,rcSetReferenceFlags]);
       if LeftResolved.BaseType=btModule then
         begin
@@ -9142,7 +9142,7 @@ begin
       else
         RaiseMsg(20190221102049,nXExpectedButYFound,sXExpectedButYFound,
           ['module or type',GetResolverResultDescription(LeftResolved,true)],NameExpr);
-      NameExpr:=Bin.right;
+      NameExpr:=Bin.Right;
       end;
     // find attribute class
     if not IsNameExpr(NameExpr) then
@@ -9821,7 +9821,7 @@ type
         end
       else if CaseExprType.ClassType=TPasRangeType then
         begin
-        ComputeElement(TPasRangeType(CaseExprType).RangeExpr.left,ElTypeResolved,[rcConstant]);
+        ComputeElement(TPasRangeType(CaseExprType).RangeExpr.Left,ElTypeResolved,[rcConstant]);
         Result:=CreateValues(ElTypeResolved,ValueSet);
         end;
       end;
@@ -10116,16 +10116,16 @@ begin
     Access:=rraAssign
   else
     Access:=rraReadAndAssign;
-  ResolveExpr(El.left,Access);
+  ResolveExpr(El.Left,Access);
   {$IFDEF VerbosePasResolver}
-  writeln('TPasResolver.ResolveImplAssign Kind=',El.Kind,' left=',GetObjName(El.left),' right=',GetObjName(el.right));
+  writeln('TPasResolver.ResolveImplAssign Kind=',El.Kind,' left=',GetObjName(El.Left),' right=',GetObjName(el.Right));
   {$ENDIF}
   // check LHS can be assigned
-  ComputeElement(El.left,LeftResolved,[rcNoImplicitProc,rcSetReferenceFlags]);
-  CheckCanBeLHS(LeftResolved,true,GetRightMostExpr(El.left));
+  ComputeElement(El.Left,LeftResolved,[rcNoImplicitProc,rcSetReferenceFlags]);
+  CheckCanBeLHS(LeftResolved,true,GetRightMostExpr(El.Left));
 
   // compute RHS
-  ResolveExpr(El.right,rraRead);
+  ResolveExpr(El.Right,rraRead);
   Flags:=[rcSetReferenceFlags];
   if IsProcedureType(LeftResolved,true) then
     begin
@@ -10137,7 +10137,7 @@ begin
   {$IFDEF VerbosePasResolver}
   writeln('TPasResolver.ResolveImplAssign Left=',GetResolverResultDbg(LeftResolved),' Flags=',dbgs(Flags));
   {$ENDIF}
-  ComputeElement(El.right,RightResolved,Flags);
+  ComputeElement(El.Right,RightResolved,Flags);
   {$IFDEF VerbosePasResolver}
   writeln('TPasResolver.ResolveImplAssign Right=',GetResolverResultDbg(RightResolved));
   {$ENDIF}
@@ -10145,10 +10145,10 @@ begin
   case El.Kind of
   akDefault:
     begin
-    CheckAssignResCompatibility(LeftResolved,RightResolved,El.right,true);
-    CheckAssignExprRange(LeftResolved,El.right);
+    CheckAssignResCompatibility(LeftResolved,RightResolved,El.Right,true);
+    CheckAssignExprRange(LeftResolved,El.Right);
     if (LeftResolved.BaseType=btContext) and (LeftResolved.LoTypeEl.ClassType=TPasArrayType) then
-      MarkArrayExprRecursive(El.right,TPasArrayType(LeftResolved.LoTypeEl));
+      MarkArrayExprRecursive(El.Right,TPasArrayType(LeftResolved.LoTypeEl));
     end;
   akAdd, akMinus,akMul,akDivision:
     begin
@@ -10157,14 +10157,14 @@ begin
       if (not (rrfReadable in RightResolved.Flags))
           or not (RightResolved.BaseType in btAllInteger) then
         RaiseMsg(20170216152009,nIncompatibleTypesGotExpected,sIncompatibleTypesGotExpected,
-          [BaseTypes[RightResolved.BaseType],BaseTypes[LeftResolved.BaseType]],El.right);
+          [BaseTypes[RightResolved.BaseType],BaseTypes[LeftResolved.BaseType]],El.Right);
       end
     else if (LeftResolved.BaseType in btAllStrings) and (El.Kind=akAdd) then
       begin
       if (not (rrfReadable in RightResolved.Flags))
           or not (RightResolved.BaseType in btAllStringAndChars) then
         RaiseMsg(20170216152012,nIncompatibleTypesGotExpected,sIncompatibleTypesGotExpected,
-          [BaseTypes[RightResolved.BaseType],BaseTypes[LeftResolved.BaseType]],El.right);
+          [BaseTypes[RightResolved.BaseType],BaseTypes[LeftResolved.BaseType]],El.Right);
       end
     else if (LeftResolved.BaseType in btAllFloats)
         and (El.Kind in [akAdd,akMinus,akMul,akDivision]) then
@@ -10172,21 +10172,21 @@ begin
       if (not (rrfReadable in RightResolved.Flags))
           or not (RightResolved.BaseType in (btAllInteger+btAllFloats)) then
         RaiseMsg(20170216152107,nIncompatibleTypesGotExpected,sIncompatibleTypesGotExpected,
-          [BaseTypes[RightResolved.BaseType],BaseTypes[LeftResolved.BaseType]],El.right);
+          [BaseTypes[RightResolved.BaseType],BaseTypes[LeftResolved.BaseType]],El.Right);
       end
     else if (LeftResolved.BaseType=btSet) and (El.Kind in [akAdd,akMinus,akMul]) then
       begin
       if (not (rrfReadable in RightResolved.Flags))
           or not (RightResolved.BaseType in [btSet,btArrayOrSet]) then
         RaiseMsg(20170216152110,nIncompatibleTypesGotExpected,sIncompatibleTypesGotExpected,
-          [BaseTypeNames[RightResolved.BaseType],'set of '+BaseTypeNames[LeftResolved.SubType]],El.right);
+          [BaseTypeNames[RightResolved.BaseType],'set of '+BaseTypeNames[LeftResolved.SubType]],El.Right);
       if (LeftResolved.SubType=RightResolved.SubType)
           or ((LeftResolved.SubType in btAllInteger) and (RightResolved.SubType in btAllInteger))
           or ((LeftResolved.SubType in btAllBooleans) and (RightResolved.SubType in btAllBooleans))
       then
       else
         RaiseMsg(20170216152117,nIncompatibleTypesGotExpected,sIncompatibleTypesGotExpected,
-          ['set of '+BaseTypeNames[RightResolved.SubType],'set of '+BaseTypeNames[LeftResolved.SubType]],El.right);
+          ['set of '+BaseTypeNames[RightResolved.SubType],'set of '+BaseTypeNames[LeftResolved.SubType]],El.Right);
       end
     else if LeftResolved.BaseType=btContext then
       begin
@@ -10204,7 +10204,7 @@ begin
     else
       RaiseIncompatibleTypeRes(20180208115707,nOperatorIsNotOverloadedAOpB,[AssignKindNames[El.Kind]],LeftResolved,RightResolved,El);
     // store const expression result
-    Value:=Eval(El.right,[]);
+    Value:=Eval(El.Right,[]);
     ReleaseEvalValue(Value);
     end;
   else
@@ -10316,10 +10316,10 @@ begin
   else
     RaiseNotYetImplemented(20170222184329,El);
 
-  if El.format1<>nil then
-    ResolveExpr(El.format1,rraRead);
-  if El.format2<>nil then
-    ResolveExpr(El.format2,rraRead);
+  if El.Format1<>nil then
+    ResolveExpr(El.Format1,rraRead);
+  if El.Format2<>nil then
+    ResolveExpr(El.Format2,rraRead);
 end;
 
 procedure TPasResolver.ResolveStatementConditionExpr(El: TPasExpr);
@@ -10426,7 +10426,7 @@ begin
       if (Access=rraAssign) and (Proc.ProcType is TPasFunctionType)
           and (El.ClassType=TPrimitiveExpr)
           and (El.Parent.ClassType=TPasImplAssign)
-          and (TPasImplAssign(El.Parent).left=El) then
+          and (TPasImplAssign(El.Parent).Left=El) then
         begin
         // e.g. funcname:=
         ProcScope:=Proc.CustomData as TPasProcedureScope;
@@ -10472,14 +10472,14 @@ begin
       if El=nil then
         RaiseInternalError(20170503002012);
       CreateReference(DeclEl,El,Access);
-      if (El.Parent is TBinaryExpr) and (TBinaryExpr(El.Parent).right=El) then
+      if (El.Parent is TBinaryExpr) and (TBinaryExpr(El.Parent).Right=El) then
         begin
         Bin:=TBinaryExpr(El.Parent);
         while Bin.OpCode=eopSubIdent do
           begin
           CreateReference(DeclEl,Bin,Access);
           if not (Bin.Parent is TBinaryExpr) then break;
-          if (TBinaryExpr(Bin.Parent).right<>Bin) then break;
+          if (TBinaryExpr(Bin.Parent).Right<>Bin) then break;
           Bin:=TBinaryExpr(Bin.Parent);
           end;
         end;
@@ -10625,7 +10625,7 @@ begin
       InhScope:=PushInheritedScope(TPasMembersType(HelperForType),false,
         AncestorScope);
       InhScope.OnlyTypeMembers:=OnlyTypeMembers;
-      ResolveExpr(El.right,Access);
+      ResolveExpr(El.Right,Access);
       PopScope;
       exit;
       end
@@ -10640,12 +10640,12 @@ begin
     end;
   // search in ancestor and its helpers
   if AncestorScope=nil then
-    RaiseMsg(20170216152151,nInheritedNeedsAncestor,sInheritedNeedsAncestor,[],El.left);
+    RaiseMsg(20170216152151,nInheritedNeedsAncestor,sInheritedNeedsAncestor,[],El.Left);
   // search call in ancestor
   AncestorClass:=TPasClassType(AncestorScope.Element);
   InhScope:=PushInheritedScope(AncestorClass,true,nil);
   InhScope.OnlyTypeMembers:=OnlyTypeMembers;
-  ResolveExpr(El.right,Access);
+  ResolveExpr(El.Right,Access);
   PopScope;
 end;
 
@@ -10656,26 +10656,26 @@ var
   Bin: TBinaryExpr;
 begin
   {$IFDEF VerbosePasResolver}
-  //writeln('TPasResolver.ResolveBinaryExpr left=',GetObjName(El.left),' right=',GetObjName(El.right),' opcode=',OpcodeStrings[El.OpCode]);
+  //writeln('TPasResolver.ResolveBinaryExpr left=',GetObjName(El.Left),' right=',GetObjName(El.Right),' opcode=',OpcodeStrings[El.OpCode]);
   {$ENDIF}
   case El.OpCode of
   eopNone:
     case El.Kind of
     pekRange:
       begin
-      ResolveExpr(El.left,rraRead);
-      if El.right=nil then exit;
-      ResolveExpr(El.right,rraRead);
+      ResolveExpr(El.Left,rraRead);
+      if El.Right=nil then exit;
+      ResolveExpr(El.Right,rraRead);
       end;
     else
-      if El.left.ClassType=TInheritedExpr then
+      if El.Left.ClassType=TInheritedExpr then
         begin
-        ResolveExpr(El.left,Access);
+        ResolveExpr(El.Left,Access);
         end
       else
         begin
         {$IFDEF VerbosePasResolver}
-        writeln('TPasResolver.ResolveBinaryExpr El.Kind=',ExprKindNames[El.Kind],' El.Left=',GetObjName(El.left),' El.Right=',GetObjName(El.right),' parent=',GetObjName(El.Parent));
+        writeln('TPasResolver.ResolveBinaryExpr El.Kind=',ExprKindNames[El.Kind],' El.Left=',GetObjName(El.Left),' El.Right=',GetObjName(El.Right),' parent=',GetObjName(El.Parent));
         {$ENDIF}
         RaiseNotYetImplemented(20160922163456,El);
         end;
@@ -10683,12 +10683,12 @@ begin
   eopAdd:
     begin
     // handle multi add
-    Left:=El.left;
+    Left:=El.Left;
     while (Left.ClassType=TBinaryExpr) do
       begin
       Bin:=TBinaryExpr(Left);
       if Bin.OpCode<>eopAdd then break;
-      Next:=TBinaryExpr(Left).left;
+      Next:=TBinaryExpr(Left).Left;
       if Next.Parent<>Left then
         RaiseNotYetImplemented(20210321201257,Left);
       Left:=Next;
@@ -10696,8 +10696,8 @@ begin
     ResolveExpr(Left,rraRead);
     repeat
       Bin:=TBinaryExpr(Left.Parent);
-      if Bin.right<>nil then
-        ResolveExpr(Bin.right,rraRead);
+      if Bin.Right<>nil then
+        ResolveExpr(Bin.Right,rraRead);
       Left:=Bin;
     until Left=El;
     end;
@@ -10724,14 +10724,14 @@ begin
   eopAs,
   eopSymmetricaldifference:
     begin
-    ResolveExpr(El.left,rraRead);
-    if El.right=nil then exit;
-    ResolveExpr(El.right,rraRead);
+    ResolveExpr(El.Left,rraRead);
+    if El.Right=nil then exit;
+    ResolveExpr(El.Right,rraRead);
     end;
   eopSubIdent:
     begin
-    ResolveExpr(El.left,rraRead);
-    if El.right=nil then exit;
+    ResolveExpr(El.Left,rraRead);
+    if El.Right=nil then exit;
     ResolveSubIdent(El,Access);
     end;
   else
@@ -10744,7 +10744,7 @@ procedure TPasResolver.ResolveSubIdent(El: TBinaryExpr;
 
   procedure ResolveRight; inline;
   begin
-    ResolveExpr(El.right,Access);
+    ResolveExpr(El.Right,Access);
     PopScope;
   end;
 
@@ -10777,7 +10777,7 @@ begin
   if El.CustomData is TResolvedReference then
     exit; // for example, when a.b has a dotted unit name
 
-  Left:=El.left;
+  Left:=El.Left;
   //writeln('TPasResolver.ResolveSubIdent Left=',GetObjName(Left));
   ComputeElement(Left,LeftResolved,[rcSetReferenceFlags]);
 
@@ -10846,7 +10846,7 @@ begin
       else
         begin
         // e.g. aPoint.X
-        AccessExpr(El.left,Access);
+        AccessExpr(El.Left,Access);
         RecordScope.OnlyTypeMembers:=false;
         end;
       ResolveRight;
@@ -10894,7 +10894,7 @@ begin
     end;
 
   {$IFDEF VerbosePasResolver}
-  writeln('TPasResolver.ResolveSubIdent left=',GetObjName(Left),' right=',GetObjName(El.right),' leftresolved=',GetResolverResultDbg(LeftResolved));
+  writeln('TPasResolver.ResolveSubIdent left=',GetObjName(Left),' right=',GetObjName(El.Right),' leftresolved=',GetResolverResultDbg(LeftResolved));
   {$ENDIF}
   RaiseMsg(20170216152157,nIllegalQualifierAfter,sIllegalQualifierAfter,
     ['.',GetResolverResultDescription(LeftResolved)],El);
@@ -10961,7 +10961,7 @@ begin
     //         /                 \
     // left = TPrimitiveExpr 'a'  right = TPrimitiveExpr 'b'
     if (Value is TBinaryExpr) and (TBinaryExpr(Value).OpCode=eopSubIdent) then
-      Value:=TBinaryExpr(Value).right;
+      Value:=TBinaryExpr(Value).Right;
     if IsNameExpr(Value) then
       begin
       ResolveBinaryExpr(TBinaryExpr(Params.Value),Access);
@@ -11414,7 +11414,7 @@ begin
     //         /                 \
     // left = TPrimitiveExpr 'a'  right = TPrimitiveExpr 'b'
     while (Value is TBinaryExpr) and (TBinaryExpr(Value).OpCode=eopSubIdent) do
-      Value:=TBinaryExpr(Value).right;
+      Value:=TBinaryExpr(Value).Right;
     if IsNameExpr(Value) then
       begin
       ResolveBinaryExpr(TBinaryExpr(Params.Value),Access);
@@ -11471,7 +11471,7 @@ begin
     if (Access=rraAssign)
         and (Proc.ProcType is TPasFunctionType)
         and (Params.Parent.ClassType=TPasImplAssign)
-        and (TPasImplAssign(Params.Parent).left=Params) then
+        and (TPasImplAssign(Params.Parent).Left=Params) then
       begin
       // e.g. funcname[]:=
       ProcScope:=Proc.CustomData as TPasProcedureScope;
@@ -11507,7 +11507,7 @@ procedure TPasResolver.ResolveArrayParamsArgs(Params: TParamsExpr;
       // -> writing the element needs reading the value
       Left:=Params.Value;
       if (Left is TBinaryExpr) and (TBinaryExpr(Left).OpCode=eopSubIdent) then
-        Left:=TBinaryExpr(Left).right;
+        Left:=TBinaryExpr(Left).Right;
       if Left.CustomData is TResolvedReference then
         begin
         Ref:=TResolvedReference(Left.CustomData);
@@ -11823,9 +11823,9 @@ begin
   if Expr.ClassType=TBinaryExpr then
     begin
     DeclEl:=nil;
-    if (TBinaryExpr(Expr).left is TPrimitiveExpr) then
+    if (TBinaryExpr(Expr).Left is TPrimitiveExpr) then
       begin
-      Prim:=TPrimitiveExpr(TBinaryExpr(Expr).left);
+      Prim:=TPrimitiveExpr(TBinaryExpr(Expr).Left);
       DeclEl:=SubResolvePrimitive(Prim);
       if not (DeclEl is TPasMembersType) then
         RaiseXExpectedButYFound(20170216151752,'class',GetElementTypeName(DeclEl),Prim);
@@ -11840,7 +11840,7 @@ begin
       PushRecordDotScope(TPasRecordType(DeclEl))
     else
       RaiseMsg(20190123145559,nIllegalQualifier,sIllegalQualifier,[OpcodeStrings[TBinaryExpr(Expr).OpCode]],Expr);
-    Expr:=TBinaryExpr(Expr).right;
+    Expr:=TBinaryExpr(Expr).Right;
     Result:=ResolveAccessor(Expr);
     PopScope;
     end
@@ -11903,7 +11903,7 @@ begin
     begin
     Bin:=TBinaryExpr(Expr);
     if Bin.OpCode in [eopSubIdent,eopNone] then
-      AccessExpr(Bin.right,Access);
+      AccessExpr(Bin.Right,Access);
     end
   else if C=TParamsExpr then
     begin
@@ -11997,8 +11997,8 @@ procedure TPasResolver.MarkArrayExprRecursive(Expr: TPasExpr;
   begin
     if IsArrayOperatorAdd(CurExpr) then
       begin
-      Traverse(TBinaryExpr(CurExpr).left,ArrayType,RgIndex);
-      Traverse(TBinaryExpr(CurExpr).right,ArrayType,RgIndex);
+      Traverse(TBinaryExpr(CurExpr).Left,ArrayType,RgIndex);
+      Traverse(TBinaryExpr(CurExpr).Right,ArrayType,RgIndex);
       end
     else if CurExpr.ClassType=TParamsExpr then
       begin
@@ -13164,16 +13164,16 @@ var
   SubBin: TBinaryExpr;
 begin
   if (Bin.OpCode=eopSubIdent)
-  or ((Bin.OpCode=eopNone) and (Bin.left is TInheritedExpr)) then
+  or ((Bin.OpCode=eopNone) and (Bin.Left is TInheritedExpr)) then
     begin
-    // Note: bin.left was already resolved via ResolveSubIdent
-    ComputeElement(Bin.right,ResolvedEl,Flags,StartEl);
+    // Note: bin.Left was already resolved via ResolveSubIdent
+    ComputeElement(Bin.Right,ResolvedEl,Flags,StartEl);
     exit;
     end;
 
   if Bin.OpCode in [eopEqual,eopNotEqual] then
     begin
-    if CheckEqualElCompatibility(Bin.left,Bin.right,nil,true,
+    if CheckEqualElCompatibility(Bin.Left,Bin.Right,nil,true,
         rcSetReferenceFlags in Flags)=cIncompatible then
       RaiseInternalError(20161007215912);
     SetResolverValueExpr(ResolvedEl,btBoolean,FBaseTypes[btBoolean],FBaseTypes[btBoolean],
@@ -13185,18 +13185,18 @@ begin
   if Bin.OpCode=eopAdd then
     begin
     // handle multi-adds without stack
-    Left:=Bin.left;
+    Left:=Bin.Left;
     while Left.ClassType=TBinaryExpr do
       begin
       SubBin:=TBinaryExpr(Left);
       if SubBin.OpCode<>eopAdd then break;
-      Left:=SubBin.left;
+      Left:=SubBin.Left;
       end;
     // Left is now left-most of multi add
     ComputeElement(Left,LeftResolved,Flags,StartEl);
     repeat
       SubBin:=TBinaryExpr(Left.Parent);
-      ComputeElement(SubBin.right,RightResolved,Flags,StartEl);
+      ComputeElement(SubBin.Right,RightResolved,Flags,StartEl);
 
       // ToDo: check operator overloading
       ComputeBinaryExprRes(SubBin,ResolvedEl,Flags,LeftResolved,RightResolved);
@@ -13206,8 +13206,8 @@ begin
     end
   else
     begin
-    ComputeElement(Bin.left,LeftResolved,Flags,StartEl);
-    ComputeElement(Bin.right,RightResolved,Flags,StartEl);
+    ComputeElement(Bin.Left,LeftResolved,Flags,StartEl);
+    ComputeElement(Bin.Right,RightResolved,Flags,StartEl);
 
     // ToDo: check operator overloading
     ComputeBinaryExprRes(Bin,ResolvedEl,Flags,LeftResolved,RightResolved);
@@ -13280,7 +13280,7 @@ begin
             if (Bin.Kind=pekRange) then
               begin
               if not (RightResolved.BaseType in btAllInteger) then
-                RaiseXExpectedButYFound(20170216152600,'integer',BaseTypeNames[RightResolved.BaseType],Bin.right);
+                RaiseXExpectedButYFound(20170216152600,'integer',BaseTypeNames[RightResolved.BaseType],Bin.Right);
               // use left type for result
               SetLeftValueExpr([rrfReadable]);
               if Bin.Parent is TPasRangeType then
@@ -13389,7 +13389,7 @@ begin
           if (Bin.Kind=pekRange) and (LeftResolved.BaseType in btAllChars) then
             begin
             if not (RightResolved.BaseType in btAllChars) then
-              RaiseXExpectedButYFound(20170216152603,'char',BaseTypeNames[RightResolved.BaseType],Bin.right);
+              RaiseXExpectedButYFound(20170216152603,'char',BaseTypeNames[RightResolved.BaseType],Bin.Right);
             SetResolverValueExpr(ResolvedEl,btRange,
               FBaseTypes[LeftResolved.BaseType],FBaseTypes[LeftResolved.BaseType],
               Bin,[rrfReadable]);
@@ -13492,7 +13492,7 @@ begin
         if (rrfReadable in LeftResolved.Flags)
             and (rrfReadable in RightResolved.Flags) then
           begin
-          CheckSetLitElCompatible(Bin.left,Bin.right,LeftResolved,RightResolved);
+          CheckSetLitElCompatible(Bin.Left,Bin.Right,LeftResolved,RightResolved);
           ResolvedEl:=LeftResolved;
           ResolvedEl.IdentEl:=nil;
           ResolvedEl.SubType:=ResolvedEl.BaseType;
@@ -13508,19 +13508,19 @@ begin
         if LeftResolved.BaseType in btArrayRangeTypes then
           begin
           if not (RightResolved.BaseType in [btSet,btArrayOrSet]) then
-            RaiseXExpectedButYFound(20170216152607,'set of '+BaseTypeNames[LeftResolved.BaseType],GetElementTypeName(LeftResolved.LoTypeEl),Bin.right);
+            RaiseXExpectedButYFound(20170216152607,'set of '+BaseTypeNames[LeftResolved.BaseType],GetElementTypeName(LeftResolved.LoTypeEl),Bin.Right);
           if LeftResolved.BaseType in btAllBooleans then
             begin
             if not (RightResolved.SubType in btAllBooleans) then
-              RaiseXExpectedButYFound(20170216152610,'set of '+BaseTypeNames[LeftResolved.BaseType],'set of '+BaseTypeNames[RightResolved.SubType],Bin.right);
+              RaiseXExpectedButYFound(20170216152610,'set of '+BaseTypeNames[LeftResolved.BaseType],'set of '+BaseTypeNames[RightResolved.SubType],Bin.Right);
             end
           else if LeftResolved.BaseType in btAllChars then
             begin
             if not (RightResolved.SubType in btAllChars) then
-              RaiseXExpectedButYFound(20170216152609,'set of '+BaseTypeNames[LeftResolved.BaseType],'set of '+BaseTypeNames[RightResolved.SubType],Bin.right);
+              RaiseXExpectedButYFound(20170216152609,'set of '+BaseTypeNames[LeftResolved.BaseType],'set of '+BaseTypeNames[RightResolved.SubType],Bin.Right);
             end
           else if not (RightResolved.SubType in btAllInteger) then
-            RaiseXExpectedButYFound(20170216152612,'set of '+BaseTypeNames[LeftResolved.BaseType],'set of '+BaseTypeNames[RightResolved.SubType],Bin.right);
+            RaiseXExpectedButYFound(20170216152612,'set of '+BaseTypeNames[LeftResolved.BaseType],'set of '+BaseTypeNames[RightResolved.SubType],Bin.Right);
           SetBaseType(btBoolean);
           exit;
           end
@@ -13528,18 +13528,18 @@ begin
             and (LeftTypeEl.ClassType=TPasEnumType) then
           begin
           if not (RightResolved.BaseType in [btSet,btArrayOrSet]) then
-            RaiseXExpectedButYFound(20170216152615,'set of '+LeftResolved.LoTypeEl.Name,GetElementTypeName(LeftResolved.LoTypeEl),Bin.right);
+            RaiseXExpectedButYFound(20170216152615,'set of '+LeftResolved.LoTypeEl.Name,GetElementTypeName(LeftResolved.LoTypeEl),Bin.Right);
           RightTypeEl:=RightResolved.LoTypeEl;
           if LeftTypeEl=RightTypeEl then
             // enum in setofenum
           else if RightResolved.LoTypeEl.ClassType=TPasRangeType then
             begin
-            ComputeElement(TPasRangeType(RightTypeEl).RangeExpr.left,ElTypeResolved,[rcConstant]);
+            ComputeElement(TPasRangeType(RightTypeEl).RangeExpr.Left,ElTypeResolved,[rcConstant]);
             if LeftTypeEl<>ElTypeResolved.LoTypeEl then
-              RaiseXExpectedButYFound(20171109215833,'set of '+LeftResolved.LoTypeEl.Name,'set of '+RightResolved.LoTypeEl.Name,Bin.right);
+              RaiseXExpectedButYFound(20171109215833,'set of '+LeftResolved.LoTypeEl.Name,'set of '+RightResolved.LoTypeEl.Name,Bin.Right);
             end
           else
-            RaiseXExpectedButYFound(20170216152618,'set of '+LeftResolved.LoTypeEl.Name,'set of '+RightResolved.LoTypeEl.Name,Bin.right);
+            RaiseXExpectedButYFound(20170216152618,'set of '+LeftResolved.LoTypeEl.Name,'set of '+RightResolved.LoTypeEl.Name,Bin.Right);
           SetBaseType(btBoolean);
           exit;
           end
@@ -13616,7 +13616,7 @@ begin
             end;
           end
         else
-          RaiseXExpectedButYFound(20170216152625,'class type',GetElementTypeName(RightResolved.LoTypeEl),Bin.right);
+          RaiseXExpectedButYFound(20170216152625,'class type',GetElementTypeName(RightResolved.LoTypeEl),Bin.Right);
         end
       else if (proClassOfIs in Options) and (LeftTypeEl is TPasClassOfType)
           and (rrfReadable in LeftResolved.Flags) then
@@ -13649,7 +13649,7 @@ begin
             end
           end
         else
-          RaiseXExpectedButYFound(20170322105252,'class type',GetElementTypeName(RightResolved.LoTypeEl),Bin.right);
+          RaiseXExpectedButYFound(20170322105252,'class type',GetElementTypeName(RightResolved.LoTypeEl),Bin.Right);
         end
       else if LeftResolved.LoTypeEl=nil then
         begin
@@ -13657,7 +13657,7 @@ begin
         writeln('TPasResolver.ComputeBinaryExprRes is-operator: left=',GetResolverResultDbg(LeftResolved),' right=',GetResolverResultDbg(RightResolved));
         {$ENDIF}
         RaiseMsg(20170216152232,nLeftSideOfIsOperatorExpectsAClassButGot,sLeftSideOfIsOperatorExpectsAClassButGot,
-                 [BaseTypeNames[LeftResolved.BaseType]],Bin.left);
+                 [BaseTypeNames[LeftResolved.BaseType]],Bin.Left);
         end
       else
         begin
@@ -13665,7 +13665,7 @@ begin
         writeln('TPasResolver.ComputeBinaryExprRes is-operator: left=',GetResolverResultDbg(LeftResolved),' right=',GetResolverResultDbg(RightResolved));
         {$ENDIF}
         RaiseMsg(20170216152234,nLeftSideOfIsOperatorExpectsAClassButGot,sLeftSideOfIsOperatorExpectsAClassButGot,
-                 [GetElementTypeName(LeftResolved.LoTypeEl)],Bin.left);
+                 [GetElementTypeName(LeftResolved.LoTypeEl)],Bin.Left);
         end;
       end;
     eopAs:
@@ -13682,11 +13682,11 @@ begin
             [OpcodeStrings[Bin.OpCode]],LeftResolved,RightResolved,Bin);
           end;
         if RightResolved.IdentEl=nil then
-          RaiseXExpectedButYFound(20170216152630,'class',GetElementTypeName(RightResolved.LoTypeEl),Bin.right);
+          RaiseXExpectedButYFound(20170216152630,'class',GetElementTypeName(RightResolved.LoTypeEl),Bin.Right);
         if not (RightResolved.IdentEl is TPasType) then
-          RaiseXExpectedButYFound(20170216152632,'class',RightResolved.IdentEl.Name,Bin.right);
+          RaiseXExpectedButYFound(20170216152632,'class',RightResolved.IdentEl.Name,Bin.Right);
         if not (RightResolved.BaseType=btContext) then
-          RaiseXExpectedButYFound(20180426195816,'class',RightResolved.IdentEl.Name,Bin.right);
+          RaiseXExpectedButYFound(20180426195816,'class',RightResolved.IdentEl.Name,Bin.Right);
         RightTypeEl:=RightResolved.LoTypeEl;
         if RightTypeEl is TPasClassType then
           begin
@@ -13730,11 +13730,11 @@ begin
           RaiseIncompatibleTypeRes(20190908191127,nOperatorIsNotOverloadedAOpB,
             [OpcodeStrings[Bin.OpCode]],LeftResolved,RightResolved,Bin);
         if RightResolved.IdentEl=nil then
-          RaiseXExpectedButYFound(20190908191202,'class',GetElementTypeName(RightResolved.LoTypeEl),Bin.right);
+          RaiseXExpectedButYFound(20190908191202,'class',GetElementTypeName(RightResolved.LoTypeEl),Bin.Right);
         if not (RightResolved.IdentEl is TPasType) then
-          RaiseXExpectedButYFound(20190908191204,'class',RightResolved.IdentEl.Name,Bin.right);
+          RaiseXExpectedButYFound(20190908191204,'class',RightResolved.IdentEl.Name,Bin.Right);
         if not (RightResolved.BaseType=btContext) then
-          RaiseXExpectedButYFound(20190908191206,'class',RightResolved.IdentEl.Name,Bin.right);
+          RaiseXExpectedButYFound(20190908191206,'class',RightResolved.IdentEl.Name,Bin.Right);
         RightTypeEl:=RightResolved.LoTypeEl;
         if RightTypeEl is TPasClassType then
           begin
@@ -15018,7 +15018,7 @@ begin
       RaiseNotYetImplemented(20161001155834,ResolvedEl.ExprEl);
   TypeEl:=ResolvedEl.LoTypeEl;
   if TypeEl is TPasRangeType then
-    ComputeElement(TPasRangeType(TypeEl).RangeExpr.left,ResolvedEl,[rcConstant])
+    ComputeElement(TPasRangeType(TypeEl).RangeExpr.Left,ResolvedEl,[rcConstant])
   else
     begin
     ResolvedEl.BaseType:=ResolvedEl.SubType;
@@ -15821,7 +15821,7 @@ begin
       else if C=TPasRangeType then
         begin
         // typecast to custom range
-        ComputeElement(TPasRangeType(Decl).RangeExpr.left,ResolvedEl,[rcConstant]);
+        ComputeElement(TPasRangeType(Decl).RangeExpr.Left,ResolvedEl,[rcConstant]);
         if ResolvedEl.BaseType=btContext then
           begin
           TypeEl:=ResolvedEl.LoTypeEl;
@@ -16572,8 +16572,8 @@ function TPasResolver.CheckGenericConstraintFitsParam(ParamType: TPasType;
     else if C=TBinaryExpr then
       begin
       Bin:=TBinaryExpr(El);
-      Result:=ElementReferencesTemplateTypes(Bin.left,GenericTemplateTypes)
-        or ElementReferencesTemplateTypes(Bin.right,GenericTemplateTypes);
+      Result:=ElementReferencesTemplateTypes(Bin.Left,GenericTemplateTypes)
+        or ElementReferencesTemplateTypes(Bin.Right,GenericTemplateTypes);
       end
     else if C=TInlineSpecializeExpr then
       begin
@@ -18478,8 +18478,8 @@ begin
   if GenEl.Elements.Count>0 then
     RaiseNotYetImplemented(20190808142935,GenEl);
   SpecEl.Kind:=GenEl.Kind;
-  SpecializeElExpr(GenEl,SpecEl,GenEl.left,SpecEl.left);
-  SpecializeElExpr(GenEl,SpecEl,GenEl.right,SpecEl.right);
+  SpecializeElExpr(GenEl,SpecEl,GenEl.Left,SpecEl.Left);
+  SpecializeElExpr(GenEl,SpecEl,GenEl.Right,SpecEl.Right);
 end;
 
 procedure TPasResolver.SpecializeImplSimple(GenEl, SpecEl: TPasImplSimple);
@@ -18563,8 +18563,8 @@ procedure TPasResolver.SpecializeExpr(GenEl, SpecEl: TPasExpr);
 begin
   SpecEl.Kind:=GenEl.Kind;
   SpecEl.OpCode:=GenEl.OpCode;
-  SpecializeElExpr(GenEl,SpecEl,GenEl.format1,SpecEl.format1);
-  SpecializeElExpr(GenEl,SpecEl,GenEl.format2,SpecEl.format2);
+  SpecializeElExpr(GenEl,SpecEl,GenEl.Format1,SpecEl.Format1);
+  SpecializeElExpr(GenEl,SpecEl,GenEl.Format2,SpecEl.Format2);
 end;
 
 procedure TPasResolver.SpecializeExprArray(GenEl, SpecEl: TPasElement;
@@ -18596,8 +18596,8 @@ end;
 procedure TPasResolver.SpecializeBinaryExpr(GenEl, SpecEl: TBinaryExpr);
 begin
   SpecializeExpr(GenEl,SpecEl);
-  SpecializeElExpr(GenEl,SpecEl,GenEl.left,SpecEl.left);
-  SpecializeElExpr(GenEl,SpecEl,GenEl.right,SpecEl.right);
+  SpecializeElExpr(GenEl,SpecEl,GenEl.Left,SpecEl.Left);
+  SpecializeElExpr(GenEl,SpecEl,GenEl.Right,SpecEl.Right);
 end;
 
 procedure TPasResolver.SpecializeBoolConstExpr(GenEl, SpecEl: TBoolConstExpr);
@@ -19139,7 +19139,7 @@ begin
         else if LoTypeEl.ClassType=TPasRangeType then
           begin
           RgType:=TPasRangeType(LoTypeEl);
-          ComputeElement(RgType.RangeExpr.left,Param0Resolved,[]);
+          ComputeElement(RgType.RangeExpr.Left,Param0Resolved,[]);
           Result:=CheckAssignResCompatibility(Param0Resolved,Param1Resolved,Param1,RaiseOnError);
           end;
         end;
@@ -19498,7 +19498,7 @@ begin
         TypeEl:=ParamResolved.LoTypeEl;
         if TypeEl.ClassType=TPasRangeType then
           begin
-          ComputeElement(TPasRangeType(TypeEl).RangeExpr.left,ResolvedEl,[rcConstant]);
+          ComputeElement(TPasRangeType(TypeEl).RangeExpr.Left,ResolvedEl,[rcConstant]);
           if ResolvedEl.LoTypeEl.ClassType=TPasEnumType then
             exit(cExact);
           end;
@@ -19970,9 +19970,9 @@ begin
     end;
   if Result=cIncompatible then
     exit(CheckRaiseTypeArgNo(20170319220517,ArgNo,Param,ParamResolved,'boolean, integer, enum value',RaiseOnError));
-  if not CheckFormat(Param.format1,1,ParamResolved) then
+  if not CheckFormat(Param.Format1,1,ParamResolved) then
     exit(cIncompatible);
-  if not CheckFormat(Param.format2,2,ParamResolved) then
+  if not CheckFormat(Param.Format2,2,ParamResolved) then
     exit(cIncompatible);
 end;
 
@@ -23903,7 +23903,7 @@ begin
 
   Value:=Params.Value;
   if Value is TBinaryExpr then
-    Value:=TBinaryExpr(Value).right; // Note: parser guarantees that this is the rightmost
+    Value:=TBinaryExpr(Value).Right; // Note: parser guarantees that this is the rightmost
 
   // check args
   ParamCnt:=length(Params.Params);
@@ -25219,7 +25219,7 @@ begin
           RTypeEl:=RHS.LoTypeEl;
           if RTypeEl.ClassType=TPasRangeType then
             begin
-            ComputeElement(TPasRangeType(RTypeEl).RangeExpr.left,RightSubResolved,[rcConstant]);
+            ComputeElement(TPasRangeType(RTypeEl).RangeExpr.Left,RightSubResolved,[rcConstant]);
             if (RightSubResolved.BaseType=btContext)
                 and IsSameType(LTypeEl,RightSubResolved.LoTypeEl,prraAlias) then
               begin
@@ -25614,7 +25614,7 @@ begin
       LTypeEl:=LHS.LoTypeEl;
       if LTypeEl.ClassType=TPasRangeType then
         begin
-        ComputeElement(TPasRangeType(LTypeEl).RangeExpr.left,ResolvedEl,[rcConstant]);
+        ComputeElement(TPasRangeType(LTypeEl).RangeExpr.Left,ResolvedEl,[rcConstant]);
         if ResolvedEl.BaseType=btContext then
           begin
           LTypeEl:=ResolvedEl.LoTypeEl;
@@ -25641,7 +25641,7 @@ begin
         RTypeEl:=RHS.LoTypeEl;
         if RTypeEl.ClassType=TPasRangeType then
           begin
-          ComputeElement(TPasRangeType(RTypeEl).RangeExpr.left,ResolvedEl,[rcConstant]);
+          ComputeElement(TPasRangeType(RTypeEl).RangeExpr.Left,ResolvedEl,[rcConstant]);
           if ResolvedEl.BaseType=btContext then
             begin
             RTypeEl:=ResolvedEl.LoTypeEl;
@@ -26816,13 +26816,13 @@ function TPasResolver.CheckAssignCompatibilityArrayType(const LHS,
         if length(ArrType.Ranges)>0 then
           exit; // ToDo: StaticArray:=A+B
         // check a:=left
-        ComputeElement(TBinaryExpr(Expr).left,ValueResolved,ExprCompFlags);
+        ComputeElement(TBinaryExpr(Expr).Left,ValueResolved,ExprCompFlags);
         CheckRange(ArrType,RangeIndex,ValueResolved,ErrorEl);
         if Result=cIncompatible then exit;
         LeftResult:=Result;
         // check a:=right
         Result:=cIncompatible;
-        ComputeElement(TBinaryExpr(Expr).right,ValueResolved,ExprCompFlags);
+        ComputeElement(TBinaryExpr(Expr).Right,ValueResolved,ExprCompFlags);
         CheckRange(ArrType,RangeIndex,ValueResolved,ErrorEl);
         if Result=cIncompatible then exit;
         if Result<LeftResult then
@@ -28757,7 +28757,7 @@ begin
       end
     else if C=TBinaryExpr then
       begin
-      if TBinaryExpr(Parent).right<>El then exit;
+      if TBinaryExpr(Parent).Right<>El then exit;
       if TBinaryExpr(Parent).OpCode<>eopSubIdent then exit;
       end
     else if C=TParamsExpr then
@@ -28772,7 +28772,7 @@ begin
       end
     else if C=TPasImplAssign then
       begin
-      if TPasImplAssign(Parent).right<>El then exit;
+      if TPasImplAssign(Parent).Right<>El then exit;
       if (msDelphi in CurrentParser.CurrentModeswitches) then exit(true);
       exit;
       end
@@ -28795,10 +28795,10 @@ begin
   C:=P.ClassType;
   if C=TBinaryExpr then
     begin
-    if TBinaryExpr(P).right=El then
+    if TBinaryExpr(P).Right=El then
       begin
       if (TBinaryExpr(P).OpCode=eopSubIdent)
-          or ((TBinaryExpr(P).OpCode=eopNone) and (TBinaryExpr(P).left is TInheritedExpr)) then
+          or ((TBinaryExpr(P).OpCode=eopNone) and (TBinaryExpr(P).Left is TInheritedExpr)) then
         Result:=ParentNeedsExprResult(TBinaryExpr(P))
       else
         Result:=true;
@@ -28840,7 +28840,7 @@ begin
     Result:=(TPasImplForLoop(P).StartExpr=El)
          or (TPasImplForLoop(P).EndExpr=El)
   else if C=TPasImplAssign then
-    Result:=(TPasImplAssign(P).right=El)
+    Result:=(TPasImplAssign(P).Right=El)
   else if C=TPasImplRaise then
     Result:=(TPasImplRaise(P).ExceptAddr=El);
 end;
@@ -28878,7 +28878,7 @@ begin
       El:=TInlineSpecializeExpr(El).NameExpr
     else if (El.ClassType=TBinaryExpr)
         and (TBinaryExpr(El).OpCode=eopSubIdent) then
-      El:=TBinaryExpr(El).right
+      El:=TBinaryExpr(El).Right
     else
       exit;
     end;

packages/fcl-passrc/src/pasuseanalyzer.pas

@@ -1544,8 +1544,8 @@ begin
   else if C=TPasImplAssign then
     // a:=b
     begin
-    UseExpr(TPasImplAssign(El).left);
-    UseExpr(TPasImplAssign(El).right);
+    UseExpr(TPasImplAssign(El).Left);
+    UseExpr(TPasImplAssign(El).Right);
     end
   else if C=TPasImplAsmStatement then
     // asm..end
@@ -1776,13 +1776,13 @@ begin
         end;
       if (Decl is TPasVariable)
           and (El.Parent is TBinaryExpr)
-          and (TBinaryExpr(El.Parent).right=El) then
+          and (TBinaryExpr(El.Parent).Right=El) then
         begin
         if ((Decl.Parent is TPasRecordType)
               or (Decl.Parent is TPasVariant)) then
           begin
           // a record member was accessed -> access the record with same Access
-          UseExprRef(El.Parent,TBinaryExpr(El.Parent).left,Access,false);
+          UseExprRef(El.Parent,TBinaryExpr(El.Parent).Left,Access,false);
           end;
         end;
       end;
@@ -1817,8 +1817,8 @@ begin
       end;
 
     end;
-  UseExpr(El.format1);
-  UseExpr(El.format2);
+  UseExpr(El.Format1);
+  UseExpr(El.Format2);
   C:=El.ClassType;
   if (C=TPrimitiveExpr)
       or (C=TBoolConstExpr)
@@ -1835,19 +1835,19 @@ begin
         begin
         Bin:=TBinaryExpr(Left);
         if Bin.OpCode<>eopAdd then break;
-        Left:=Bin.left;
+        Left:=Bin.Left;
         end;
       UseExpr(Left);
       repeat
         Bin:=TBinaryExpr(Left.Parent);
-        UseExpr(Bin.right);
+        UseExpr(Bin.Right);
         Left:=Bin;
       until Left=El;
       end
     else
       begin
-      UseExpr(Bin.left);
-      UseExpr(Bin.right);
+      UseExpr(Bin.Left);
+      UseExpr(Bin.Right);
       end;
     end
   else if C=TUnaryExpr then
@@ -1895,7 +1895,7 @@ begin
     begin
     Bin:=TBinaryExpr(Expr);
     if Bin.OpCode in [eopSubIdent,eopNone] then
-      UseExprRef(El,Bin.right,Access,UseFull);
+      UseExprRef(El,Bin.Right,Access,UseFull);
     end
   else if C=TParamsExpr then
     begin

packages/fcl-passrc/src/pparser.pp

@@ -2192,12 +2192,12 @@ begin
     Result:=OpcodeStrings[TUnaryExpr(Expr).OpCode]+ExprToText(TUnaryExpr(Expr).Operand)
   else if C=TBinaryExpr then
     begin
-    Result:=ExprToText(TBinaryExpr(Expr).left);
+    Result:=ExprToText(TBinaryExpr(Expr).Left);
     if OpcodeStrings[TBinaryExpr(Expr).OpCode]<>'' then
       Result:=Result+OpcodeStrings[TBinaryExpr(Expr).OpCode]
     else
       Result:=Result+' ';
-    Result:=Result+ExprToText(TBinaryExpr(Expr).right)
+    Result:=Result+ExprToText(TBinaryExpr(Expr).Right)
     end
   else if C=TParamsExpr then
     begin
@@ -2301,11 +2301,11 @@ begin
           else
             begin
             NextToken;
-            Expr.format1:=DoParseExpression(Expr);
+            Expr.Format1:=DoParseExpression(Expr);
             if (CurToken=tkColon) then
               begin
               NextToken;
-              Expr.format2:=DoParseExpression(Expr);
+              Expr.Format2:=DoParseExpression(Expr);
               end;
             end;
         if not (CurToken in [tkComma, PClose]) then
@@ -2490,7 +2490,7 @@ begin
         begin
         SrcPos:=CurTokenPos;
         Bin:=CreateBinaryExpr(AParent,Last,ParseExprOperand(AParent),eopNone,SrcPos);
-        if not Assigned(Bin.right) then
+        if not Assigned(Bin.Right) then
           begin
           Bin.Release{$IFDEF CheckPasTreeRefCount}('CreateElement'){$ENDIF};
           ParseExcExpectedIdentifier;
@@ -2628,7 +2628,7 @@ begin
             Bin:=TBinaryExpr(Expr);
             if Bin.OpCode<>eopSubIdent then
               ParseExcSyntaxError;
-            Expr:=Bin.right;
+            Expr:=Bin.Right;
             end
           else
             Bin:=nil;
@@ -2823,7 +2823,7 @@ begin
           x:=PopExp;
           if (TempOp=tkMinus) and (x.Kind=pekRange) then
             begin
-            TBinaryExpr(x).Left:=CreateUnaryExpr(x, TBinaryExpr(x).left,
+            TBinaryExpr(x).Left:=CreateUnaryExpr(x, TBinaryExpr(x).Left,
                                                  eopSubtract, SrcPos);
             ExpStack.Add(x);
             end
@@ -6625,13 +6625,13 @@ begin
               begin
               // assign statement
               El:=TPasImplAssign(CreateElement(TPasImplAssign,'',CurBlock,SrcPos));
-              TPasImplAssign(El).left:=Left;
+              TPasImplAssign(El).Left:=Left;
               Left.Parent:=El;
               Left:=nil;
               TPasImplAssign(El).Kind:=TokenToAssignKind(CurToken);
               NextToken;
               Right:=DoParseExpression(CurBlock);
-              TPasImplAssign(El).right:=Right;
+              TPasImplAssign(El).Right:=Right;
               Right.Parent:=El;
               Right:=nil;
               AddStatement(El);
@@ -7942,12 +7942,12 @@ begin
   Result.Kind:=pekBinary;
   if xleft<>nil then
     begin
-    Result.left:=xleft;
+    Result.Left:=xleft;
     xleft.Parent:=Result;
     end;
   if xright<>nil then
     begin
-    Result.right:=xright;
+    Result.Right:=xright;
     xright.Parent:=Result;
     end;
 end;

packages/fcl-passrc/tests/tcexprparser.pas

@@ -308,9 +308,9 @@ begin
   B:=TBinaryExpr(AssertExpression('Binary of record',P.Value,pekBinary,TBinaryExpr));
   AssertEquals('Name is Subident',eopSubIdent,B.Opcode);
   AssertExpression('Name of array',B.Left,pekIdent,'b');
-  AssertExpression('Name of array',B.right,pekIdent,'a');
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
+  AssertExpression('Name of array',B.Right,pekIdent,'a');
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
 end;
 
 procedure TTestExpressions.TestArrayElement2Dims;
@@ -386,8 +386,8 @@ begin
   AssertExpression('Left is 0',B.Left,pekNumber,'0');
   AssertExpression('Right is 10',B.Right,pekNumber,'10');
   B:=TBinaryExpr(TheExpr);
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
 end;
 
 procedure TTestExpressions.TestBracketsTotal;
@@ -1089,7 +1089,7 @@ begin
   AssertEquals('Have initialization statement',1,PasProgram.InitializationSection.Elements.Count);
   AssertNotNull('Have initialization statement',PasProgram.InitializationSection.Elements[0]);
   AssertEquals('Assignment statement',TPasImplAssign,TObject(PasProgram.InitializationSection.Elements[0]).ClassType);
-  FTheExpr:=TPasImplAssign(PasProgram.InitializationSection.Elements[0]).right;
+  FTheExpr:=TPasImplAssign(PasProgram.InitializationSection.Elements[0]).Right;
   AssertNotNull('Have assignment expression',FTheExpr);
 end;
 
@@ -1115,8 +1115,8 @@ begin
   ARight:=Result.Right;
   AssertNotNull('Have left',ALeft);
   AssertNotNull('Have right',ARight);
-  TAssert.AssertSame('Result.left.parent=B',Result,Result.left.Parent);
-  TAssert.AssertSame('Result.right.parent=B',Result,Result.right.Parent);
+  TAssert.AssertSame('Result.left.parent=B',Result,Result.Left.Parent);
+  TAssert.AssertSame('Result.right.parent=B',Result,Result.Right.Parent);
 end;
 
 function TTestExpressions.AssertUnaryExpr(const Msg: String; Op: TExprOpCode;
@@ -1153,10 +1153,10 @@ begin
   TAssert.AssertSame('P.params[0].parent=P',P,P.params[0].Parent);
   TAssert.AssertSame('P.params[1].parent=P',P,P.params[1].Parent);
   B:=TBinaryExpr(AssertExpression('Binary identifier',P.Value,pekBinary,TBinaryExpr));
-  AssertExpression('Name of unit',B.left,pekIdent,'system');
-  AssertExpression('Name of function',B.right,pekIdent,'str');
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
+  AssertExpression('Name of unit',B.Left,pekIdent,'system');
+  AssertExpression('Name of function',B.Right,pekIdent,'str');
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
 end;
 
 procedure TTestExpressions.TestAPlusCallB;
@@ -1168,10 +1168,10 @@ begin
   DeclareVar('integer','b');
   ParseExpression('a+b(1)');
   B:=TBinaryExpr(AssertExpression('Binary identifier',TheExpr,pekBinary,TBinaryExpr));
-  AssertExpression('left a',B.left,pekIdent,'a');
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
-  P:=TParamsExpr(AssertExpression('Params',B.right,pekFuncParams,TParamsExpr));
+  AssertExpression('left a',B.Left,pekIdent,'a');
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
+  P:=TParamsExpr(AssertExpression('Params',B.Right,pekFuncParams,TParamsExpr));
   TAssert.AssertSame('P.value.parent=P',P,P.Value.Parent);
   AssertEquals('1 argument',1,Length(p.params));
   AssertExpression('param 1',p.params[0],pekNumber,'1');
@@ -1190,10 +1190,10 @@ begin
   AssertEquals('1 argument',1,Length(p.params));
   AssertExpression('param 1',p.params[0],pekNumber,'1');
   B:=TBinaryExpr(AssertExpression('Binary identifier',P.Value,pekBinary,TBinaryExpr));
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
-  AssertExpression('left a',B.left,pekIdent,'a');
-  AssertExpression('right b',B.right,pekIdent,'b');
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
+  AssertExpression('left a',B.Left,pekIdent,'a');
+  AssertExpression('right b',B.Right,pekIdent,'b');
 end;
 
 procedure TTestExpressions.TestAPlusBBracketArrayParams;
@@ -1210,10 +1210,10 @@ begin
   AssertExpression('param 1',p.params[0],pekNumber,'1');
 
   B:=TBinaryExpr(AssertExpression('Binary identifier',P.Value,pekBinary,TBinaryExpr));
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
-  AssertExpression('left a',B.left,pekIdent,'a');
-  AssertExpression('right b',B.right,pekIdent,'b');
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
+  AssertExpression('left a',B.Left,pekIdent,'a');
+  AssertExpression('right b',B.Right,pekIdent,'b');
 end;
 
 procedure TTestExpressions.TestAPlusBBracketDotC;
@@ -1225,15 +1225,15 @@ begin
   ParseExpression('(a+b).c');
   B:=TBinaryExpr(AssertExpression('Binary identifier',TheExpr,pekBinary,TBinaryExpr));
   AssertEquals('().',eopSubIdent,B.OpCode);
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
-  AssertExpression('right c',B.right,pekIdent,'c');
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
+  AssertExpression('right c',B.Right,pekIdent,'c');
 
-  PlusB:=TBinaryExpr(AssertExpression('Binary identifier',B.left,pekBinary,TBinaryExpr));
-  TAssert.AssertSame('PlusB.left.parent=PlusB',PlusB,PlusB.left.Parent);
-  TAssert.AssertSame('PlusB.right.parent=PlusB',PlusB,PlusB.right.Parent);
-  AssertExpression('left a',PlusB.left,pekIdent,'a');
-  AssertExpression('right b',PlusB.right,pekIdent,'b');
+  PlusB:=TBinaryExpr(AssertExpression('Binary identifier',B.Left,pekBinary,TBinaryExpr));
+  TAssert.AssertSame('PlusB.left.parent=PlusB',PlusB,PlusB.Left.Parent);
+  TAssert.AssertSame('PlusB.right.parent=PlusB',PlusB,PlusB.Right.Parent);
+  AssertExpression('left a',PlusB.Left,pekIdent,'a');
+  AssertExpression('right b',PlusB.Right,pekIdent,'b');
 end;
 
 procedure TTestExpressions.TestADotBDotC;
@@ -1243,15 +1243,15 @@ begin
   ParseExpression('a.b.c');
   B:=TBinaryExpr(AssertExpression('Binary identifier',TheExpr,pekBinary,TBinaryExpr));
   AssertEquals('dot expr',eopSubIdent,B.OpCode);
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
-  AssertExpression('right c',B.right,pekIdent,'c');
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
+  AssertExpression('right c',B.Right,pekIdent,'c');
 
-  SubB:=TBinaryExpr(AssertExpression('Binary identifier',B.left,pekBinary,TBinaryExpr));
-  TAssert.AssertSame('PlusB.left.parent=PlusB',SubB,SubB.left.Parent);
-  TAssert.AssertSame('PlusB.right.parent=PlusB',SubB,SubB.right.Parent);
-  AssertExpression('left a',SubB.left,pekIdent,'a');
-  AssertExpression('right b',SubB.right,pekIdent,'b');
+  SubB:=TBinaryExpr(AssertExpression('Binary identifier',B.Left,pekBinary,TBinaryExpr));
+  TAssert.AssertSame('PlusB.left.parent=PlusB',SubB,SubB.Left.Parent);
+  TAssert.AssertSame('PlusB.right.parent=PlusB',SubB,SubB.Right.Parent);
+  AssertExpression('left a',SubB.Left,pekIdent,'a');
+  AssertExpression('right b',SubB.Right,pekIdent,'b');
 end;
 
 procedure TTestExpressions.TestADotBBracketC;
@@ -1264,10 +1264,10 @@ begin
 
   B:=TBinaryExpr(AssertExpression('Binary identifier',P.Value,pekBinary,TBinaryExpr));
   AssertEquals('dot expr',eopSubIdent,B.OpCode);
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
-  AssertExpression('left a',B.left,pekIdent,'a');
-  AssertExpression('right b',B.right,pekIdent,'b');
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
+  AssertExpression('left a',B.Left,pekIdent,'a');
+  AssertExpression('right b',B.Right,pekIdent,'b');
 
   AssertEquals('length(p.Params)',length(p.Params),1);
   AssertExpression('first param c',p.Params[0],pekIdent,'c');
@@ -1283,10 +1283,10 @@ begin
 
   B:=TBinaryExpr(AssertExpression('Binary identifier',P.Value,pekBinary,TBinaryExpr));
   AssertEquals('dot expr',eopSubIdent,B.OpCode);
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
-  AssertEquals('left self',TSelfExpr,B.left.classtype);
-  AssertExpression('right b',B.right,pekIdent,'b');
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
+  AssertEquals('left self',TSelfExpr,B.Left.classtype);
+  AssertExpression('right b',B.Right,pekIdent,'b');
 
   AssertEquals('length(p.Params)',length(p.Params),1);
   AssertExpression('first param c',p.Params[0],pekIdent,'c');
@@ -1304,18 +1304,18 @@ begin
 
   B:=TBinaryExpr(AssertExpression('Upper Binary identifier',P.Value,pekBinary,TBinaryExpr));
   AssertEquals('dot c expr',eopSubIdent,B.OpCode);
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
 
-  AssertExpression('dot c',b.right,pekIdent,'c');
+  AssertExpression('dot c',b.Right,pekIdent,'c');
 
-  AsExpr:=TBinaryExpr(AssertExpression('lower binary identifier',B.left,pekBinary,TBinaryExpr));
+  AsExpr:=TBinaryExpr(AssertExpression('lower binary identifier',B.Left,pekBinary,TBinaryExpr));
   AssertEquals('AS expr',eopAs,AsExpr.OpCode);
-  TAssert.AssertSame('AsExpr.left.parent=AsExpr',AsExpr,AsExpr.left.Parent);
-  TAssert.AssertSame('AsExpr.right.parent=AsExpr',AsExpr,AsExpr.right.Parent);
+  TAssert.AssertSame('AsExpr.left.parent=AsExpr',AsExpr,AsExpr.Left.Parent);
+  TAssert.AssertSame('AsExpr.right.parent=AsExpr',AsExpr,AsExpr.Right.Parent);
 
-  AssertExpression('left AS a',AsExpr.left,pekIdent,'a');
-  AssertExpression('right AS b',AsExpr.right,pekIdent,'b');
+  AssertExpression('left AS a',AsExpr.Left,pekIdent,'a');
+  AssertExpression('right AS b',AsExpr.Right,pekIdent,'b');
 end;
 
 procedure TTestExpressions.TestParseAdhocExpression;
@@ -1330,8 +1330,8 @@ begin
   Parser.NextToken;
   Parser.ParseAdhocExpression(ExprElement);
   BinaryExpression := AssertExpression('Some expression, parsed separately',ExprElement,pekBinary,TBinaryExpr) as TBinaryExpr;
-  AssertExpression('Some expression, parsed separately, left part', BinaryExpression.left, pekBoolConst, TBoolConstExpr);
-  AssertExpression('Some expression, parsed separately, right part',BinaryExpression.right, pekBoolConst, TBoolConstExpr);
+  AssertExpression('Some expression, parsed separately, left part', BinaryExpression.Left, pekBoolConst, TBoolConstExpr);
+  AssertExpression('Some expression, parsed separately, right part',BinaryExpression.Right, pekBoolConst, TBoolConstExpr);
 end;
 
 initialization

packages/fcl-passrc/tests/tconstparser.pas

@@ -265,8 +265,8 @@ begin
   ParseConst('1 + 2');
   CheckExprNameKindClass(pekBinary,TBinaryExpr);
   B:=TBinaryExpr(TheExpr);
-  TAssert.AssertSame('B.Left.Parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.Parent=B',B,B.right.Parent);
+  TAssert.AssertSame('B.Left.Parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.Parent=B',B,B.Right.Parent);
   AssertExpression('Left expression',B.Left,pekNumber,'1');
   AssertExpression('Right expression',B.Right,pekNumber,'2');
 end;
@@ -682,8 +682,8 @@ begin
   ParseResourcestring('''Something''+'' else''');
   CheckExprNameKindClass(pekBinary,TBinaryExpr);
   B:=TBinaryExpr(TheExpr);
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
   AssertEquals('Correct left',TPrimitiveExpr,B.Left.ClassType);
   AssertEquals('Correct right',TPrimitiveExpr,B.Right.ClassType);
   AssertEquals('Correct left expression value','''Something''',TPrimitiveExpr(B.Left).Value);
@@ -697,8 +697,8 @@ begin
   ParseResourcestring('''Something''+different');
   CheckExprNameKindClass(pekBinary,TBinaryExpr);
   B:=TBinaryExpr(TheExpr);
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
   AssertEquals('Correct left',TPrimitiveExpr,B.Left.ClassType);
   AssertEquals('Correct right',TPrimitiveExpr,B.Right.ClassType);
   AssertEquals('Correct left expression value','''Something''',TPrimitiveExpr(B.Left).Value);

packages/fcl-passrc/tests/tcresolver.pas

@@ -2543,10 +2543,10 @@ begin
     E('El.Parent=El='+GetObjName(El));
   if El is TBinaryExpr then
     begin
-    if (TBinaryExpr(El).left<>nil) and (TBinaryExpr(El).left.Parent<>El) then
-      E('TBinaryExpr(El).left.Parent='+GetObjName(TBinaryExpr(El).left.Parent)+'<>El');
-    if (TBinaryExpr(El).right<>nil) and (TBinaryExpr(El).right.Parent<>El) then
-      E('TBinaryExpr(El).right.Parent='+GetObjName(TBinaryExpr(El).right.Parent)+'<>El');
+    if (TBinaryExpr(El).Left<>nil) and (TBinaryExpr(El).Left.Parent<>El) then
+      E('TBinaryExpr(El).left.Parent='+GetObjName(TBinaryExpr(El).Left.Parent)+'<>El');
+    if (TBinaryExpr(El).Right<>nil) and (TBinaryExpr(El).Right.Parent<>El) then
+      E('TBinaryExpr(El).right.Parent='+GetObjName(TBinaryExpr(El).Right.Parent)+'<>El');
     end
   else if El is TParamsExpr then
     begin
@@ -5737,8 +5737,8 @@ begin
   El:=TPasElement(Module.InitializationSection.Elements[0]);
   AssertEquals('direct assign',TPasImplAssign,El.ClassType);
   Assign1:=TPasImplAssign(El);
-  AssertEquals('direct assign left',TPrimitiveExpr,Assign1.left.ClassType);
-  Prim1:=TPrimitiveExpr(Assign1.left);
+  AssertEquals('direct assign left',TPrimitiveExpr,Assign1.Left.ClassType);
+  Prim1:=TPrimitiveExpr(Assign1.Left);
   AssertNotNull(Prim1.CustomData);
   AssertEquals('direct assign left ref',TResolvedReference,Prim1.CustomData.ClassType);
   DeclEl:=TResolvedReference(Prim1.CustomData).Declaration;
@@ -5748,10 +5748,10 @@ begin
   El:=TPasElement(Module.InitializationSection.Elements[1]);
   AssertEquals('indirect assign',TPasImplAssign,El.ClassType);
   Assign2:=TPasImplAssign(El);
-  AssertEquals('indirect assign left',TBinaryExpr,Assign2.left.ClassType);
-  BinExp:=TBinaryExpr(Assign2.left);
-  AssertEquals('indirect assign first token',TPrimitiveExpr,BinExp.left.ClassType);
-  Prim1:=TPrimitiveExpr(BinExp.left);
+  AssertEquals('indirect assign left',TBinaryExpr,Assign2.Left.ClassType);
+  BinExp:=TBinaryExpr(Assign2.Left);
+  AssertEquals('indirect assign first token',TPrimitiveExpr,BinExp.Left.ClassType);
+  Prim1:=TPrimitiveExpr(BinExp.Left);
   AssertEquals('indirect assign first token','afile',Prim1.Value);
   AssertNotNull(Prim1.CustomData);
   AssertEquals('indirect assign unit ref resolved',TResolvedReference,Prim1.CustomData.ClassType);
@@ -5760,8 +5760,8 @@ begin
 
   AssertEquals('indirect assign dot',eopSubIdent,BinExp.OpCode);
 
-  AssertEquals('indirect assign second token',TPrimitiveExpr,BinExp.right.ClassType);
-  Prim2:=TPrimitiveExpr(BinExp.right);
+  AssertEquals('indirect assign second token',TPrimitiveExpr,BinExp.Right.ClassType);
+  Prim2:=TPrimitiveExpr(BinExp.Right);
   AssertEquals('indirect assign second token','eXitCode',Prim2.Value);
   AssertNotNull(Prim2.CustomData);
   AssertEquals('indirect assign var ref resolved',TResolvedReference,Prim2.CustomData.ClassType);
@@ -5773,10 +5773,10 @@ begin
   El:=TPasElement(Module.InitializationSection.Elements[2]);
   AssertEquals('other unit assign',TPasImplAssign,El.ClassType);
   Assign3:=TPasImplAssign(El);
-  AssertEquals('other unit assign left',TBinaryExpr,Assign3.left.ClassType);
-  BinExp:=TBinaryExpr(Assign3.left);
-  AssertEquals('othe unit assign first token',TPrimitiveExpr,BinExp.left.ClassType);
-  Prim1:=TPrimitiveExpr(BinExp.left);
+  AssertEquals('other unit assign left',TBinaryExpr,Assign3.Left.ClassType);
+  BinExp:=TBinaryExpr(Assign3.Left);
+  AssertEquals('othe unit assign first token',TPrimitiveExpr,BinExp.Left.ClassType);
+  Prim1:=TPrimitiveExpr(BinExp.Left);
   AssertEquals('other unit assign first token','System',Prim1.Value);
   AssertNotNull(Prim1.CustomData);
   AssertEquals('other unit assign unit ref resolved',TResolvedReference,Prim1.CustomData.ClassType);
@@ -5787,8 +5787,8 @@ begin
 
   AssertEquals('other unit assign dot',eopSubIdent,BinExp.OpCode);
 
-  AssertEquals('other unit assign second token',TPrimitiveExpr,BinExp.right.ClassType);
-  Prim2:=TPrimitiveExpr(BinExp.right);
+  AssertEquals('other unit assign second token',TPrimitiveExpr,BinExp.Right.ClassType);
+  Prim2:=TPrimitiveExpr(BinExp.Right);
   AssertEquals('other unit assign second token','exiTCode',Prim2.Value);
   AssertNotNull(Prim2.CustomData);
   AssertEquals('other unit assign var ref resolved',TResolvedReference,Prim2.CustomData.ClassType);

packages/fcl-passrc/tests/tcstatements.pas

@@ -411,8 +411,8 @@ begin
   S:=Statement as TPasImplSimple;
   AssertExpression('Doit call',S.Expr,pekBinary,TBinaryExpr);
   B:=S.Expr as TBinaryExpr;
-  TAssert.AssertSame('B.left.Parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.Parent=B',B,B.right.Parent);
+  TAssert.AssertSame('B.left.Parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.Parent=B',B,B.Right.Parent);
   AssertExpression('Unit name',B.Left,pekIdent,'Unita');
   AssertExpression('Doit call',B.Right,pekIdent,'Doit');
 end;
@@ -430,10 +430,10 @@ begin
   AssertExpression('Doit call',S.Expr,pekBinary,TBinaryExpr);
   B:=S.Expr as TBinaryExpr;
   AssertExpression('Doit call',B.Right,pekIdent,'Doit');
-  AssertExpression('First two parts of unit name',B.left,pekBinary,TBinaryExpr);
-  B:=B.left as TBinaryExpr;
+  AssertExpression('First two parts of unit name',B.Left,pekBinary,TBinaryExpr);
+  B:=B.Left as TBinaryExpr;
   AssertExpression('Unit name part 1',B.Left,pekIdent,'Unita');
-  AssertExpression('Unit name part 2',B.right,pekIdent,'ClassB');
+  AssertExpression('Unit name part 2',B.Right,pekIdent,'ClassB');
 end;
 
 procedure TTestStatementParser.TestCallNoArgs;
@@ -479,9 +479,9 @@ var
   procedure CheckParam(Index: integer; const aParamName: string);
   begin
     AssertExpression('Parameter['+IntToStr(Index)+'] is identifier',P.Params[Index],pekIdent,aParamName);
-    AssertExpression('Parameter['+IntToStr(Index)+'] has formatting constant 1' ,P.Params[Index].format1,pekNumber,'3');
+    AssertExpression('Parameter['+IntToStr(Index)+'] has formatting constant 1' ,P.Params[Index].Format1,pekNumber,'3');
     if AddPrecision then
-      AssertExpression('Parameter['+IntToStr(Index)+'] has formatting constant 2',P.Params[Index].format2,pekNumber,'2');
+      AssertExpression('Parameter['+IntToStr(Index)+'] has formatting constant 2',P.Params[Index].Format2,pekNumber,'2');
   end;
 
 Var
@@ -939,12 +939,12 @@ begin
   AssertEquals('Up loop',False,F.Down);
   AssertExpression('Start expression',F.StartExpr,pekBinary,TBinaryExpr);
   B:=F.StartExpr as TBinaryExpr;
-  AssertExpression('Start value left',B.left,pekNumber,'1');
-  AssertExpression('Start value right',B.right,pekNumber,'1');
+  AssertExpression('Start value left',B.Left,pekNumber,'1');
+  AssertExpression('Start value right',B.Right,pekNumber,'1');
   AssertExpression('Start expression',F.StartExpr,pekBinary,TBinaryExpr);
   B:=F.EndExpr as TBinaryExpr;
-  AssertExpression('End value left',B.left,pekNumber,'5');
-  AssertExpression('End value right',B.right,pekNumber,'5');
+  AssertExpression('End value left',B.Left,pekNumber,'5');
+  AssertExpression('End value right',B.Right,pekNumber,'5');
   AssertNull('Empty body',F.Body);
 end;
 

packages/fcl-passrc/tests/tctypeparser.pas

@@ -760,13 +760,13 @@ begin
   AssertEquals('argument expr type', TBinaryExpr, A.ValueExpr.ClassType);
   B:=TBinaryExpr(A.ValueExpr);
   AssertNotNull('have left expr', B.Left);
-  AssertEquals('argument left expr type', TPrimitiveExpr, B.left.ClassType);
+  AssertEquals('argument left expr type', TPrimitiveExpr, B.Left.ClassType);
   AssertEquals('argument left expr value', '1', TPrimitiveExpr(B.Left).Value);
   AssertNotNull('have right expr', B.Right);
-  AssertEquals('argument right expr type', TPrimitiveExpr, B.right.ClassType);
-  AssertEquals('argument right expr value', '2', TPrimitiveExpr(B.right).Value);
-  TAssert.AssertSame('B.left.parent=B',B,B.left.Parent);
-  TAssert.AssertSame('B.right.parent=B',B,B.right.Parent);
+  AssertEquals('argument right expr type', TPrimitiveExpr, B.Right.ClassType);
+  AssertEquals('argument right expr value', '2', TPrimitiveExpr(B.Right).Value);
+  TAssert.AssertSame('B.left.parent=B',B,B.Left.Parent);
+  TAssert.AssertSame('B.right.parent=B',B,B.Right.Parent);
 end;
 
 procedure TTestProcedureTypeParser.DoTestProcedureOneArgDefaultSet(

packages/fcl-passrc/tests/tcvarparser.pas

@@ -240,8 +240,8 @@ begin
   ParseVar('q absolute v.w','');
   AssertVariableType('q');
   B:=AssertExpression('binary',TheVar.AbsoluteExpr,eopSubIdent);
-  AssertExpression('correct absolute expr v',B.left,pekIdent,'v');
-  AssertExpression('correct absolute expr w',B.right,pekIdent,'w');
+  AssertExpression('correct absolute expr v',B.Left,pekIdent,'v');
+  AssertExpression('correct absolute expr w',B.Right,pekIdent,'w');
 end;
 
 procedure TTestVarParser.TestSimpleVarAbsolute2Dots;
@@ -251,10 +251,10 @@ begin
   ParseVar('q absolute v.w.x','');
   AssertVariableType('q');
   B:=AssertExpression('binary',TheVar.AbsoluteExpr,eopSubIdent);
-  AssertExpression('correct absolute expr x',B.right,pekIdent,'x');
-  B:=AssertExpression('binary',B.left,eopSubIdent);
-  AssertExpression('correct absolute expr w',B.right,pekIdent,'w');
-  AssertExpression('correct absolute expr v',B.left,pekIdent,'v');
+  AssertExpression('correct absolute expr x',B.Right,pekIdent,'x');
+  B:=AssertExpression('binary',B.Left,eopSubIdent);
+  AssertExpression('correct absolute expr w',B.Right,pekIdent,'w');
+  AssertExpression('correct absolute expr v',B.Left,pekIdent,'v');
 end;
 
 procedure TTestVarParser.TestVarProcedure;