Exception.RaiseOuterException vs. W1035 Return value of function '%s' might be undefined

One way I can think of to avoid the warning, without disabling it, is to do the following instead:

function F(X: NativeInt): NativeInt;
begin
  try
    Result := 1 div X;
  except
    on E: Exception do
    begin
      if E is EDivByZero then
        Exception.RaiseOuterException({ECustom}Exception.Create('...'));
      raise;
    end;
  end;
end;

UPDATE: Another way, as stated in a comment, would be to simply define a return value that is not actually reached at runtime, eg:

function F(X: NativeInt): NativeInt;
begin
  try
    Result := 1 div X;
  except
    on E: EDivByZero do
    begin
      Exception.RaiseOuterException({ECustom}Exception.Create('...'));
      Result := 0; // <-- just to keep the compiler happy
    end;
  end;
end;

EChainedException solution

(as requested by Max)

Update I have put out a FR for this at Embarcadero. Please vote if you like this proposed solution. RSP-31679

By using this class, the inner exception is always recorded "as if" you had called Exception.RaiseOuterException. This allows you to use the simple raise statement, this avoids the warning message being issued by the compiler.

Useage

Just derive your custom exceptions from EChainedException instead of Exception, and use raise rather then Exception.RaiseOuterException.

Sourcecode

The relevant code is below. My complete EChainedException is a bit more complicated than this for supporting detection of fatal exceptions and stacktracing etc. If it doesn't compile, let me know what's missing and I'll add the missing part.

unit uChainedException;

interface

uses Sysutils;

{$M+} // ensures RTTI info is present for EChainedException

type
    EChainedException = class(Exception)
    protected
      procedure RaisingException(P: system.sysutils.PExceptionRecord); override;
    end;

implementation

uses rtti;

var // rtti pointers for handling the inner exception
  vInnerExceptionOffset: NativeInt = -1;
  vAcquireInnerExceptionOffset: NativeInt = -1;
  vRunningInIDEInitialized: Boolean;
  vRunningInIDE: Boolean;

function RunningInIDE:boolean;
begin
  if not vRunningInIDEInitialized then
  begin
    vRunningInIDE:=AnsiSameText(ExtractFileName(ParamStr(0)),'BDS.EXE');
    vRunningInIDEInitialized:=True;
  end;
  Result:=vRunningInIDE;
end;


procedure EChainedException.RaisingException(P: System.sysutils.PExceptionRecord);
var
  PBoolean: ^Boolean;
  PObject : ^TObject;
begin
  if (ExceptObject<>self) and (vAcquireInnerExceptionOffset >=0)  then
  begin
    PBoolean := Pointer(NativeInt(Self)+vAcquireInnerExceptionOffset);
    PBoolean^ := PBoolean^ or not RunningInIDE;
  end;
  inherited;
  // in some rare cases (like reraise exception from another thread)
  // it may happen that the innerexception points to self
  // this is corrected here.
  if InnerException=self then
  begin
    PObject := Pointer(NativeInt(Self)+vInnerExceptionOffset);
    PObject^ := nil;
  end;
end;

procedure UnprepAutoInnerException;
begin
  vInnerExceptionOffset:=-1;
  vAcquireInnerExceptionOffset:=-1;
end;

procedure PrepAutoInnerException;
var
  lRTTIContext: TRttiContext;
  lInnerException:TRttiField;
  lAcquireInnerException:TRttiField;
  lClass: TRttiInstanceType;
begin
  try
    lRTTIContext.Create;     //Notice vRTTIContext is a record, .Create initializes properties
    try
      lClass:=lRTTIContext.GetType(Exception) as TRttiInstanceType;
      lInnerException:=lClass.GetField('FInnerException');
      vInnerExceptionOffset := lInnerException.Offset;
      lAcquireInnerException:=lClass.GetField('FAcquireInnerException');
      vAcquireInnerExceptionOffset := lAcquireInnerException.Offset;
    except
      UnprepAutoInnerException;
      raise;
    end;
  finally
    lRTTIContext.Free;
  end;
end;

initialization
  PrepAutoInnerException;
finalization
  UnprepAutoInnerException;
end.

Looking at this code I find it could use some modernizing, eg by using class vars instead of globals, and by using inline locale variables. The entire unit is back from Delphi 6 days and contains many $ifdefs, and left out because it would surpass the answer.

I still wonder why exception chaining is not the default in delphi/rad studio like it is in other languages. Most likely because it would break existing code somehow.

I (also) answer my own question as I will take yet another approach. It provides for the following requirements:

• I like to keep the raise statements, as they initially were,
  • so there won't be any necessary code changes here, and
  • which also means there won't be newly introduced warnings like W1035 or W1036.
• I don't want to rebuild the inner RTL mechanics, however
• I want to interfere with the RTL mechanics as little as possible.
• I want to be flexible in controlling for chaining exceptions
  • sometimes forced or by default, on the exception implementation side, as well as
  • sometimes by argument, on the exception usage side, to extend functionality.

In my solution:

• I accept to break through the Exception fields' visibility, FAcquireInnerException specifically.
• I rely on RTTI to verify the fields' alignment (in ExceptionFields, according to Exception).

Here I provide a condensed implementation to copy-and-paste:

EException's constructor showcases the use of ExceptionFields:

ExceptionFields(Self).FAcquireInnerException := True;

-- to be used in any Exception-derived exception, and it will trigger the RTL mechanics to set the InnerException while it is raising the exception. Also, EException may serve as a common root for custom exception classes, if desired. Some constructors are reintroduced to be extended with const AcquireInnerException: Boolean = True, to hand-over the control to the caller while providing a default for the desired chaining.

Run ExceptionFields.VerifyFieldAlignments, if you want to verify the alignments of

• the ("re-") declared externally accessible fields in ExceptionFields and
• their (private) counterparts in Exception.

If it cannot verify this, it will raise an exception. It is run in EException's class constructor. Move it as propriate to you, if you do not use EException, yet want to keep the verification.

(Condensed) implementation:

unit Exceptions;

interface

uses
  System.SysUtils;

type
  EException = class (Exception)
  public
    class constructor Create;
    constructor Create(const Msg: String; const AcquireInnerException: Boolean = True);
    constructor CreateFmt(const Msg: String; const Args: array of const; const AcquireInnerException: Boolean = True); overload;
    constructor CreateRes(const Msg: PResStringRec; const AcquireInnerException: Boolean = True);
    constructor CreateResFmt(const Msg: PResStringRec; const Args: array of const; const AcquireInnerException: Boolean = True); overload;
  end;

type
  ExceptionFields = class (TObject)
  {$Hints Off} // H2219
  strict private
    FMessage: String;
    FHelpContext: Integer;
    FInnerException: Exception;
    FStackInfo: Pointer;
  {$Hints On}

  public
    FAcquireInnerException: Boolean;

  private
    class procedure VerifyFieldAlignments;
  end;

implementation

uses
  System.Generics.Collections,
  System.RTTI,
  System.TypInfo;

{ ExceptionFields }

class procedure ExceptionFields.VerifyFieldAlignments;

  procedure RaiseTypeNotFound(const ClassName: String);
  begin
    raise Exception.CreateFmt(
      'Typ nicht gefunden: %s',
      [ClassName]
    );
  end;

  procedure RaiseFieldNotFound(const ClassName, FieldName: String);
  begin
    raise Exception.CreateFmt(
      'Feld nicht gefunden: %s.%s',
      [ClassName, FieldName]
    );
  end;

  procedure RaiseFieldNotAligned(const LeftClassName: String; const LeftField: TPair<String, Integer>; const RightClassName: String; const RightField: TRTTIField);
  begin
    raise Exception.CreateFmt(
      'Feld nicht ausgerichtet: %s.%s+%d (tatsächlich) vs. %s.%s+%d (erwartet)',
      [
        LeftClassName,
        LeftField.Key,
        LeftField.Value,
        RightClassName,
        RightField.Name,
        RightField.Offset
      ]
    );
  end;

  type
    TMemberVisibilities = set of TMemberVisibility;

  function GetDeclaredFields(const RTTIContext: TRTTIContext; const &Class: TClass; const IncludedVisibilities: TMemberVisibilities = [mvPublic, mvPublished]): TArray<TPair<String, Integer>>;
  var
    RTTIType: TRTTIType;
    RTTIFields: TArray<TRTTIField>;
    Index: NativeInt;
    RTTIField: TRTTIField;
  begin
    RTTIType := RTTIContext.GetType(&Class);
    if not Assigned(RTTIType) then
      RaiseTypeNotFound(&Class.ClassName);
    RTTIFields := RTTIType.GetDeclaredFields;
    SetLength(Result, Length(RTTIFields));
    Index := 0;
    for RTTIField in RTTIFields do
      if RTTIField.Visibility in IncludedVisibilities then
      begin
        Result[Index] := TPair<String, Integer>.Create(
          RTTIField.Name,
          RTTIField.Offset
        );
        Inc(Index);
      end;
    SetLength(Result, Index);
  end;

const
  Left: TClass = ExceptionFields;
  Right: TClass = Exception;
var
  RTTIContext: TRTTIContext;
  DeclaredFields: TArray<TPair<String, Integer>>;
  RTTIType: TRTTIType;
  DeclaredField: TPair<String, Integer>;
  RTTIField: TRTTIField;
begin
  RTTIContext := TRTTIContext.Create;
  try
    DeclaredFields := GetDeclaredFields(RTTIContext, Left);
    RTTIType := RTTIContext.GetType(Right);
    if not Assigned(RTTIType) then
      RaiseTypeNotFound(Right.ClassName);
    for DeclaredField in DeclaredFields do
    begin
      RTTIField := RTTIType.GetField(DeclaredField.Key);
      if not Assigned(RTTIField) then
        RaiseFieldNotFound(Right.ClassName, DeclaredField.Key);
      if DeclaredField.Value <> RTTIField.Offset then
        RaiseFieldNotAligned(
          Left.ClassName, DeclaredField,
          RTTIType.Name, RTTIField
        );
    end;
  finally
    RTTIContext.Free;
  end;
end;

{ EException }

class constructor EException.Create;
begin
  inherited;
  ExceptionFields.VerifyFieldAlignments;
end;

constructor EException.Create(const Msg: String;
  const AcquireInnerException: Boolean);
begin
  inherited Create(Msg);
  ExceptionFields(Self).FAcquireInnerException := AcquireInnerException;
end;

constructor EException.CreateFmt(const Msg: String;
  const Args: array of const;
  const AcquireInnerException: Boolean);
begin
  inherited CreateFmt(Msg, Args);
  ExceptionFields(Self).FAcquireInnerException := AcquireInnerException;
end;

constructor EException.CreateRes(const Msg: PResStringRec;
  const AcquireInnerException: Boolean);
begin
  inherited CreateRes(Msg);
  ExceptionFields(Self).FAcquireInnerException := AcquireInnerException;
end;

constructor EException.CreateResFmt(const Msg: PResStringRec;
  const Args: array of const;
  const AcquireInnerException: Boolean);
begin
  inherited CreateResFmt(Msg, Args);
  ExceptionFields(Self).FAcquireInnerException := AcquireInnerException;
end;

end.

And a demo:

program ExceptionsDemo;

{$AppType Console}

{$R *.res}

uses
  System.SysUtils,
  Exceptions in 'Exceptions.pas';

type
  EDemoException = class (EException)
  end;

begin
  try
    try
      try
        raise EZeroDivide.Create('Level 3');
      except
        raise EException.Create('Level 2', False);
      end;
    except
      raise EDemoException.Create('Level 1');
    end;
  except
    on E: Exception do
    begin
      WriteLn(E.ClassName, ': ', E.Message);
      while Assigned(E.InnerException) do
      begin
        E := E.InnerException;
        WriteLn(E.ClassName, ': ', E.Message);
      end;
    end;
  end;
  ReadLn;
end.

Output -- the last line is only there on raise EException.Create('Level 2', True):

EDemoException: Level 1
EException: Level 2
EZeroDivide: Level 3

Thank you to all repliers!