dmd.escape
Most of the logic to implement scoped pointers and scoped references is here.
License
Source: escape.d
Documentation: https://dlang.org/phobos/dmd_escape.html
-
Declaration
bool
checkMutableArguments
(Scope*sc
, FuncDeclarationfd
, TypeFunctiontf
, Expressionethis
, Expressions*arguments
, boolgag
);Checks memory objects passed to a function. Checks that if a memory object is passed by ref or by pointer, all of the refs or pointers are const, or there is only one mutable ref or pointer to it.
References: DIP 1021
Parameters
Scope*
sc
used to determine current function and module
FuncDeclaration
fd
function being called
TypeFunction
tf
fd
's typeExpression
ethis
if not
null
, thethis
pointerExpressions*
arguments
actual
arguments
to functionbool
gag
do not print error messages
Return Value
true
if error -
Declaration
bool
checkArrayLiteralEscape
(Scope*sc
, ArrayLiteralExpae
, boolgag
);Array literal is going to be allocated on the GC heap. Check its elements to see if any would escape by going on the heap.
Parameters
Scope*
sc
used to determine current function and module
ArrayLiteralExp
ae
array literal expression
bool
gag
do not print error messages
Return Value
true
if any elements escaped -
Declaration
bool
checkAssocArrayLiteralEscape
(Scope*sc
, AssocArrayLiteralExpae
, boolgag
);Associative array literal is going to be allocated on the GC heap. Check its elements to see if any would escape by going on the heap.
Parameters
Scope*
sc
used to determine current function and module
AssocArrayLiteralExp
ae
associative array literal expression
bool
gag
do not print error messages
Return Value
true
if any elements escaped -
Declaration
bool
checkParamArgumentEscape
(Scope*sc
, FuncDeclarationfdc
, Parameterpar
, Expressionarg
, boolassertmsg
, boolgag
);Function parameter
is being initialized topar
, andarg
may escape. Detect if scoped values can escape this way. Print error messages when these are detected.par
Parameters
Scope*
sc
used to determine current function and module
FuncDeclaration
fdc
function being called,
null
if called indirectlyParameter
par
function parameter (
this
ifnull
)Expression
arg
initializer for param
bool
assertmsg
true
if the parameter is the msg argument to assert(bool, msg).bool
gag
do not print error messages
Return Value
true
if pointers to the stack can escape via assignment -
Declaration
bool
checkParamArgumentReturn
(Scope*sc
, ExpressionfirstArg
, Expressionarg
, boolgag
);Function argument initializes a
return
parameter, and that parameter gets assigned to
. Essentially, treat asfirstArg
firstArg
=arg
;Parameters
Scope*
sc
used to determine current function and module
Expression
firstArg
ref
argument through which
may be assignedarg
Expression
arg
initializer for parameter
bool
gag
do not print error messages
Return Value
true
if assignment to
would cause an errorfirstArg
-
Declaration
bool
checkConstructorEscape
(Scope*sc
, CallExpce
, boolgag
);Check struct constructor of the form
s.this(args)
, by checking eachreturn
parameter to see if it gets assigned tos
.Parameters
Scope*
sc
used to determine current function and module
CallExp
ce
constructor call of the form
s.this(args)
bool
gag
do not print error messages
Return Value
true
if construction would cause an escaping reference error -
Declaration
bool
checkAssignEscape
(Scope*sc
, Expressione
, boolgag
);Given an
AssignExp
, determine if the lvalue will cause the contents of the rvalue to escape. Print error messages when these are detected. Inferscope
attribute for the lvalue where possible, in order to eliminate the error.Parameters
Scope*
sc
used to determine current function and module
Expression
e
AssignExp
orCatAssignExp
to check for any pointers to the stackbool
gag
do not print error messages
Return Value
true
if pointers to the stack can escape via assignment -
Declaration
bool
checkThrowEscape
(Scope*sc
, Expressione
, boolgag
);Detect cases where pointers to the stack can escape the lifetime of the stack frame when throwing
. Print error messages when these are detected.e
Parameters
Scope*
sc
used to determine current function and module
Expression
e
expression to check for any pointers to the stack
bool
gag
do not print error messages
Return Value
true
if pointers to the stack can escape -
Declaration
bool
checkNewEscape
(Scope*sc
, Expressione
, boolgag
);Detect cases where pointers to the stack can escape the lifetime of the stack frame by being placed into a GC allocated object. Print error messages when these are detected.
Parameters
Scope*
sc
used to determine current function and module
Expression
e
expression to check for any pointers to the stack
bool
gag
do not print error messages
Return Value
true
if pointers to the stack can escape -
Declaration
bool
checkReturnEscape
(Scope*sc
, Expressione
, boolgag
);Detect cases where pointers to the stack can escape the lifetime of the stack frame by returning
by value. Print error messages when these are detected.e
Parameters
Scope*
sc
used to determine current function and module
Expression
e
expression to check for any pointers to the stack
bool
gag
do not print error messages
Return Value
true
if pointers to the stack can escape -
Declaration
bool
checkReturnEscapeRef
(Scope*sc
, Expressione
, boolgag
);Detect cases where returning
bye
ref
can result in a reference to the stack being returned. Print error messages when these are detected.Parameters
Scope*
sc
used to determine current function and module
Expression
e
expression to check
bool
gag
do not print error messages
Return Value
true
if references to the stack can escape -
Declaration
void
escapeByValue
(Expressione
, EscapeByResults*er
, boollive
= false);e
is an expression to be returned by value, and that value contains pointers. Walke
to determine which variables are possibly being returned by value, such as: int* function(int* p) { return p; } Ife
is a form of &p, determine which variables have content which is being returned as ref, such as: int* function(int i) { return &i; } Multiple variables can be inserted, because of expressions like this: int function(bool b, int i, int* p) { return b ? &i : p; }Discussion
No side effects.
Parameters
Expression
e
expression to be returned by value
EscapeByResults*
er
where to place collected data
bool
live
if @
live
semantics apply, i.e
. expressionsp
,*p
,**p
, etc., all returnp
. -
Declaration
void
escapeByRef
(Expressione
, EscapeByResults*er
, boollive
= false);e
is an expression to be returned by 'ref'. Walke
to determine which variables are possibly being returned by ref, such as: ref int function(int i) { return i; } Ife
is a form of p, determine which variables have content which is being returned as ref, such as: ref int function(int) p { return p; } Multiple variables can be inserted, because of expressions like this: ref int function(bool b, int i, int) p { return b ? i : *p; }Discussion
No side effects.
Parameters
Expression
e
expression to be returned by 'ref'
EscapeByResults*
er
where to place collected data
bool
live
if @
live
semantics apply, i.e
. expressionsp
,*p
,**p
, etc., all returnp
. -
Declaration
struct
EscapeByResults
;Aggregate the data collected by the escapeBy??() functions.
-
Declaration
void
reset
();Reset arrays so the storage can be used again
-
-
Declaration
void
findAllOuterAccessedVariables
(FuncDeclarationfd
, VarDeclarations*vars
);Find all variables accessed by this delegate that are in functions enclosing it.
Parameters
FuncDeclaration
fd
function
VarDeclarations*
vars
array to append found variables to
-
Declaration
void
notMaybeScope
(VarDeclarationv
);Turn off
STC.maybescope
for variable
.v
Discussion
This exists in order to find where
STC.maybescope
is getting turned off.Parameters
VarDeclaration
v
variable
-
Declaration
void
eliminateMaybeScopes
(VarDeclaration[]array
);Have some variables that are maybescopes that were assigned values from other maybescope variables. Now that semantic analysis of the function is complete, we can finalize this by turning off maybescope for
array
elements that cannot be scope.Discussion
Parameters
VarDeclaration[]
array
array
of variables that were assigned to from maybescope variables -
Declaration
bool
isReferenceToMutable
(Typet
);Is type a reference to a mutable value?
Discussion
This is used to determine if an argument that does not have a corresponding Parameter, i.e. a variadic argument, is a pointer to mutable data.
Parameters
Type
t
type of the argument
Return Value
true
if it's a pointer (or reference) to mutable data -
Declaration
bool
isReferenceToMutable
(Parameterp
, Typet
);Is parameter a reference to a mutable value?
Discussion
This is used if an argument has a corresponding Parameter. The argument type is necessary if the Parameter is inout.
Parameters
Parameter
p
Parameter to check
Type
t
type of corresponding argument
Return Value
true
if it's a pointer (or reference) to mutable data