public FunctionCompiler(Compiler compiler, Function func, DataType parameterizedParent, AstScope body)
: this(compiler)
{
Function = func;
Namescope = func.GenericType ?? parameterizedParent;
Body = body;
}
public AstFinalizer(Source src, string comment, IReadOnlyList <AstAttribute> attrs, Modifiers modifiers, string cond, IReadOnlyList <AstParameter> paramList, AstScope body)
: base(comment, attrs, modifiers, cond)
{
Source = src;
Parameters = paramList;
OptionalBody = body;
}
public FunctionCompiler(Compiler compiler, Function func, DataType parameterizedParent, AstScope declarationBody)
: this(compiler)
{
Function = func;
Namescope = (func as Method)?.GenericType ?? parameterizedParent;
DeclarationBody = declarationBody;
}
public void Mangle(AstToplevel topLevel)
{
var output = new OutputContext(_outputOptions);
output.InitializeForFrequencyCounting();
if (_options.FrequencyCounting)
{
topLevel.Print(output);
}
_options.Chars = output.FinishFrequencyCounting();
Walk(topLevel);
foreach (var s in _options.Reserved)
{
var idx = AstScope.Debase54(_options.Chars, s);
if (idx >= 0)
{
_options.ReservedOrIdentifier.Add((uint)idx);
}
}
foreach (var s in OutputContext.ReservedWords)
{
var idx = AstScope.Debase54(_options.Chars, s);
if (idx >= 0)
{
_options.ReservedOrIdentifier.Add((uint)idx);
}
}
for (var i = 0u; i < _toMangle.Count; i++)
{
_toMangle[i].Mangle(_options);
}
}
public AstConverter(string comment, IReadOnlyList <AstAttribute> attrs, Modifiers modifiers, string cond, AstExpression targetTypeExpression, IReadOnlyList <AstParameter> argList, AstScope body)
: base(comment, attrs, modifiers, cond)
{
TargetType = targetTypeExpression;
Parameters = argList;
OptionalBody = body;
}
public AstAccessor(Source src, Modifiers modifiers, string cond, AstScope body)
: base(src)
{
Modifiers = modifiers;
OptionalCondition = cond;
OptionalBody = body;
}
public AstMethod(string comment, IReadOnlyList <AstAttribute> attrs, Modifiers modifiers, string cond, AstExpression dataType, AstExpression optionalInterfaceType, AstIdentifier name, IReadOnlyList <AstParameter> argList, AstGenericSignature optionalGenericSig, AstScope body)
: base(comment, attrs, modifiers, cond, dataType, name)
{
OptionalInterfaceType = optionalInterfaceType;
Parameters = argList;
OptionalGenericSignature = optionalGenericSig;
OptionalBody = body;
}
protected override void Visit(AstNode node)
{
switch (node)
{
case AstLabeledStatement _:
{
// _labelIndex is incremented when we get to the AstLabel
var saveLabelIndex = _labelIndex;
DescendOnce();
_labelIndex = saveLabelIndex;
break;
}
case AstScope scope:
{
foreach (var def in scope.Variables.Values)
{
if (_options.Reserved.Contains(def.Name))
{
continue;
}
_toMangle.Add(def);
}
break;
}
case IMayBeBlockScope blockScope when blockScope.IsBlockScope:
{
foreach (var def in blockScope.BlockScope.Variables.Values)
{
if (_options.Reserved.Contains(def.Name))
{
continue;
}
_toMangle.Add(def);
}
break;
}
case AstLabel label:
{
string name;
do
{
name = AstScope.Base54(_options.Chars, _labelIndex++);
}while (!OutputContext.IsIdentifier(name));
label.MangledName = name;
StopDescending();
break;
}
case AstSymbolCatch symbolCatch:
_toMangle.Add(symbolCatch.Thedef);
break;
}
}
public AstOperator(Source src, string comment, IReadOnlyList <AstAttribute> attrs, Modifiers modifiers, string cond, AstExpression returnType, OperatorType op, IReadOnlyList <AstParameter> argList, AstScope body)
: base(comment, attrs, modifiers, cond)
{
Source = src;
ReturnType = returnType;
Operator = op;
Parameters = argList;
OptionalBody = body;
}
public AstConstructor(Source src, string comment, IReadOnlyList <AstAttribute> attributes, Modifiers modifiers, string cond, IReadOnlyList <AstParameter> paramList,
AstConstructorCallType callType = 0, IReadOnlyList <AstArgument> callArgs = null, AstScope body = null)
: base(comment, attributes, modifiers, cond)
{
Source = src;
CallType = callType;
CallArguments = callArgs;
Parameters = paramList;
OptionalBody = body;
}
public SymbolDef(AstScope scope, AstSymbol orig, AstNode?init)
{
Name = orig.Name;
Scope = scope;
Orig = new StructList <AstSymbol>();
Orig.Add(orig);
Init = init;
References = new StructList <AstSymbol>();
Global = false;
MangledName = null;
MangledIdx = -2;
Undeclared = false;
Defun = null;
}
AstScope ProcessScopeNode(AstScope astScope)
{
if (_isInScope)
{
return(astScope);
}
_isInScope = true;
Descend();
_isInScope = false;
if (_astVarCount == 0 || _astVarCount == 1 && !_canPerformMergeDefAndInit && astScope.Body[0] is AstVar)
{
return(astScope);
}
return(HoistVariables(astScope));
}
public void Mangle(ScopeOptions options)
{
if (MangledName != null)
{
return;
}
if (Unmangleable(options))
{
if (!options.IgnoreEval && Scope.Pinned())
{
var mangledIdx = AstScope.Debase54(options.Chars, Name);
var enc = Scope.Enclosed.AsReadOnlySpan();
foreach (var encSym in enc)
{
if (encSym.MangledIdx == mangledIdx && encSym.MangledName != null)
{
encSym.MangledName = null;
encSym.Mangle(options);
}
}
}
return;
}
var def = Redefined();
if (def != null)
{
if (def.MangledIdx >= 0)
{
MangledName = def.MangledName;
MangledIdx = def.MangledIdx;
}
else
{
MangledName = def.Name;
MangledIdx = AstScope.Debase54(options.Chars, MangledName);
}
}
else
{
(MangledName, MangledIdx) = ((string, int))Scope.NextMangled(options, this);
}
}
public Scope CompileScope(Source src, AstScope s)
{
var vscope = new VariableScope();
var scope = new Scope(src);
VariableScopeStack.Add(vscope);
foreach (var e in s.Statements)
{
scope.Statements.Add(CompileStatement(e));
}
if (s.IsClosed)
{
VariableScopeStack.Remove(vscope);
CurrentVariableScope.Scopes.Add(vscope);
}
return(scope);
}
public void WriteScope(AstScope a)
{
Write(a.Source);
WriteStatements(a.Statements);
}
public SetupScopeChainingAndHandleDefinitionsTreeWalker(ScopeOptions options, AstToplevel astToplevel)
{
_options = options;
_currentScope = astToplevel.ParentScope = null;
_defun = null;
}
protected override void Visit(AstNode node)
{
if (node is IMayBeBlockScope blockScope && blockScope.IsBlockScope)
{
var saveScope = _currentScope;
blockScope.BlockScope = _currentScope = new AstScope(node);
_currentScope.InitScopeVars(saveScope);
if (!(node is AstScope))
{
_currentScope.UsesWith = saveScope.UsesWith;
_currentScope.UsesEval = saveScope.UsesEval;
_currentScope.HasUseStrictDirective = saveScope.HasUseStrictDirective;
}
DescendOnce();
_currentScope = saveScope;
return;
}
if (node is AstDestructuring destructuring)
{
_inDestructuring = destructuring; // These don't nest
DescendOnce();
_inDestructuring = null;
return;
}
if (node is AstScope astScope)
{
astScope.InitScopeVars(_currentScope);
var saveScope = _currentScope;
var saveDefun = _defun;
var saveLabels = _labels;
_labels = new Dictionary <string, AstLabel>();
_defun = _currentScope = astScope;
DescendOnce();
_defun = saveDefun;
_currentScope = saveScope;
_labels = saveLabels;
return;
}
if (node is AstLabeledStatement labeledStatement)
{
var l = labeledStatement.Label;
if (!_labels.TryAdd(l.Name, l))
{
throw new Exception($"Label {l.Name} defined twice");
}
DescendOnce();
_labels.Remove(l.Name);
return;
}
if (node is AstWith)
{
for (var s = _currentScope; s != null; s = s.ParentScope)
{
s.UsesWith = true;
}
return;
}
if (node is AstSymbol astSymbol)
{
astSymbol.Scope = _currentScope;
}
if (node is AstLabel astLabel)
{
astLabel.References = new StructList <AstLoopControl>();
}
else if (node is AstSymbolLambda astSymbolLambda)
{
_defun.DefFunction(astSymbolLambda, astSymbolLambda.Name == "arguments" ? null : _defun);
}
else if (node is AstSymbolDefun astSymbolDefun)
{
// This should be defined in the parent scope, as we encounter the
// AstDefun node before getting to its AstSymbol.
MarkExport((astSymbolDefun.Scope = _defun.ParentScope.Resolve()).DefFunction(astSymbolDefun, _defun),
1);
}
else if (node is AstSymbolClass)
{
MarkExport(_defun.DefVariable((AstSymbol)node, _defun), 1);
}
else if (node is AstSymbolImport)
{
_currentScope.DefVariable((AstSymbol)node, null);
}
else if (node is AstSymbolDefClass)
{
// This deals with the name of the class being available
// inside the class.
MarkExport((((AstSymbol)node).Scope = _defun.ParentScope).DefFunction((AstSymbol)node, _defun), 1);
}
else if (node is AstSymbolVar ||
node is AstSymbolLet ||
node is AstSymbolConst)
{
SymbolDef def;
if (node is AstSymbolBlockDeclaration)
{
def = _currentScope.DefVariable((AstSymbol)node, null);
}
else
{
def = _defun.DefVariable((AstSymbol)node, null);
}
if (!def.Orig.All(sym =>
{
if (sym == node)
{
return(true);
}
if (node is AstSymbolBlockDeclaration)
{
return(sym is AstSymbolLambda);
}
return(!(sym is AstSymbolLet || sym is AstSymbolConst));
}))
{
throw new Exception(((AstSymbol)node).Name + " redeclared");
}
MarkExport(def, 2);
def.Destructuring = _inDestructuring;
if (_defun != _currentScope)
{
((AstSymbol)node).MarkEnclosed(_options);
var def2 = _currentScope.FindVariable((AstSymbol)node);
if (((AstSymbol)node).Thedef != def2)
{
((AstSymbol)node).Thedef = def2;
((AstSymbol)node).Reference(_options);
}
}
}
else if (node is AstSymbolCatch astSymbolCatch)
{
_currentScope.DefVariable(astSymbolCatch, null).Defun = _defun;
}
else if (node is AstLabelRef labelRef)
{
if (_labels.TryGetValue(labelRef.Name, out var sym))
{
labelRef.Thedef = sym;
}
else
{
throw new Exception(
$"Undefined label {labelRef.Name} [{labelRef.Start.Line},{labelRef.Start.Column}]");
}
}
if (!(_currentScope is AstToplevel) && (node is AstExport || node is AstImport))
{
throw new Exception(node.PrintToString() + " statement may only appear at top level");
}
}
public Scope CompileScope(AstScope scope)
{
return(CompileScope(scope.Source, scope));
}
