Usare il WITH - fate attenzione

[DragoRosso]

Mi collego al topic presente sul forum internazionale di Lazarus: https://forum.lazarus.freepascal.org/index.php/topic,69755.msg542298/topicseen.html

Il topic presenta un caso d'uso abbastanza comune tra i programmatori (in realtà io uso il WITH in rari casi), ossia l'uso del WITH come blocco per "accorciare" la scrittura del codice, e magari renderla più chiara (che poi è la funzione del WITH).

Il compilatore di FPC in questo caso presentato in realtà "ignora praticamente" il codice (diciamo che il codice scritto non ha alcun effetto). Questo è uno dei tipici casi in cui purtroppo si vengono a creare quelle situazioni che provocano dei bug clamorosi difficili poi da diagnosticare.

Sul WITH si è dibattuto più e più volte (ho partecipato a più webinar su questo argomento) perchè sembra che quel blocco "abbreviato" non sia molto gradito agli stessi compilatori (sia in Delphi che in FPC, ognuno a vari livelli). Anche se potrebbe sembrare, Delphi non ne è immune anche se è forse un pò più evoluto nel controllo.

Per cui ciò che voglio consigliare a tutti è di fare attenzione con l'uso del WITH, e di verificare più a fondo che ciò che stà all'interno del blocco sia congruo senza fidarsi ciecamente del compilatore.

Questo è un esempio di codice incriminato:

Codice: [Seleziona]

    program Project1;
     
    type
      TTest = record
        V: Integer;
      end;
     
    var
      X: TTest;
     
      function Test: TTest;
      begin
        Result := X;
      end;
     
    var
      T: TTest;
    begin
      with Test do
        V := 1;       //Nessun Errore
      Test.V := 1; //Errore: Argument cannot be assigned to
    end.

P.S.: gli effetti del codice entro il WITH e la linea successiva dovrebbero essere identici in quanto le due scritture sono esattamente equivalenti, ma il codice entro il WITH viene riportato come valido, quando in realtà non lo è.

[nomorelogic]

questo errore del compilatore non lo conoscevo...
certo lascia un po' perplessi 

[DragoRosso]

questo errore del compilatore non lo conoscevo...
certo lascia un po' perplessi 

Non lo sapevo per quello che riguardava FPC, per Delphi in passato c'erano già state delle avvisaglie su alcuni aspetti, non così impattanti ... ma un errore è sempre un errore, se scrivo:

a := 1;

e il compilatore non lo compila (senza errori) può essere grave o no, rimane il fatto che il codice che scrivo non viene "attuato" dal compilatore ed è ciò che è grave.
E su questo FPC e Delphi sono andati a braccetto su alcuni aspetti.
Come ho scritto, Delphi non soffre di questo "bug" ma nei vari webinar mi è sembrato di capire che il WITH non sia molto "digerito" dai compilatori, probabilmente perchè devono eseguire una "inference" sui dati e ciò sembra sia un pò ostico.

Ho sempre visto il WITH come un potenziale pericolo e ciò che è successo me lo ha semplicemente confermato.

Faccio un esempio banale, cosa che alcune volte (rare ..) mi è capitato di fare:

se uso il WITH con un oggetto che ha la proprietà ROW ad esempio ed uso il ROW entro il blocco WITH questo mi viene correttamente "agganciato" all'oggetto stesso.
Ma se per uno spiacevole equivoco (CHE NON DOVREBBE MAI ACCADERE) la proprietà ROW sparisse dall'oggetto (anche nell'immediato futuro), allora quel ROW verrebbe preso dal compilatore come una variabile normale e quindi potrebbe "agganciarla" ad una variabile globale ad esempio.

Codice normale:

Codice: [Seleziona]

type
  TProva = record
      ROW: integer;
  end;

var Prova: TProva;

begin
    WITH Prova do
       ROW := 5;
end;

Codice futuro .... bacato:

Codice: [Seleziona]

//In una UNIT molto lontana e dimenticata una variabile globale ROW venne dichiarata ....
var ROW: integer;
.....
.....
type
  TProva = record
      ROWS: integer;   //cambio del nome..... DA NON FARE MAI DOPO AVER PUBBLICATO IL CODICE !!!!
  end;

var Prova: TProva;

begin
    WITH Prova do
       ROW := 5;         //NON E' il ROW del codice precedente ... vai a scoprirlo poi .....
                                // .... non ti bastano gli inferni disponibili di una vita da quante bestemmie tiri
end;

[xinyiman]

Ma daiiiii, che comportamento anomalo (per non dire altro). Fortuna non lo uso da una vita.

[DragoRosso]

La discussione in quel topic si è prolungata nel frattempo.

E sembra che il bug (perchè è un bug e non ci sono ne santi ne madonne che tengano) non venga ritenuto un bug in quanto comunque il codice scritto è errato e quindi non intendono sprecare energie con un intervento.

Uno dei più titolati del forum se l'è un pò presa (sempre civilmente) perchè ho accennato che Delphi rileva ciò come un errore  e perchè ritengo (ma avevo premesso che sono l'ultimo a cui dare credito) che il compilatore debba segnalare ciò che non è corretto nel codice.

Devo dire che quanto ho visto non mi è piaciuto per niente, perchè mi pare si punti più a difendere l'orticello piuttosto che vederla a campo largo, e se ciò potrebbe andare bene in un forum come il nostro, in un forum di riferimento come quello internazionale ...

Io rimango dell'idea che il compilatore DEVE segnalare codice errato, sempre e comunque. Non può essere che io scriva un schifezza e che il compilatore me la passi per buona, indifferentemente se ciò ha un peso o meno.
 
Ciao

[nomorelogic]

comunque nel thread in inglese c'è uno che ha criticato chi ha criticato te 

sul quel caso specifico di WITH c'è poco da obiettare: quel codice è errato ed il compilatore dovrebbe segnalarlo
che poi "romperebbe" codice pre-esistente può anche darsi, ma sarebbe un bene!
soprattutto in un linguaggio che fa del type-safe una bandiera

per altri usi WITH mi piace molto ma lo uso sempre con cautela
per esempio lo evito volentieri quando ci sono parametri di una funzione che si chiamano come proprietà di qualcosa
tipo

Codice: [Seleziona]

function saluta(const nome: string): string;
type 
   TEsempio = record
      nome: string;
      saluto: string;
   end;

var e: TEsempio;
begin

   with e do begin
      saluto := 'ciao';
      nome := nome;  // chissà cosa verrà assegnato qua...
      result := saluto + ' ' + nome;  // chissà cosa verrà concatenato qua...
   end;

end;