private UstSpecific.ArrayPatternExpression VisitArrayPattern(ArrayPattern arrayPattern)
{
var elements = new Collections.List <ParameterDeclaration>(arrayPattern.Elements.Count);
foreach (IArrayPatternElement elem in arrayPattern.Elements)
{
ParameterDeclaration paramDecl = VisitArrayPatternElement(elem);
elements.Add(paramDecl);
}
return(new UstSpecific.ArrayPatternExpression(elements, GetTextSpan(arrayPattern)));
}
private void ExtractVariableExports(ModuleData module, ArrayPattern arrayPattern)
{
for (int i = 0, n = arrayPattern.Elements.Count; i < n; i++)
{
switch (arrayPattern.Elements[i])
{
case Identifier identifier:
module.ExportsRaw.Add(new NamedExportData(identifier.Name));
break;
case ArrayPattern nestedArrayPattern:
ExtractVariableExports(module, nestedArrayPattern);
break;
case ObjectPattern nestedObjectPattern:
ExtractVariableExports(module, nestedObjectPattern);
break;
case RestElement restElement:
ExtractVariableExports(module, restElement);
break;
}
}
}
public virtual void VisitArrayPattern(ArrayPattern arrayPattern)
{
}
protected virtual void VisitArrayPattern(ArrayPattern arrayPattern)
{
}
protected override void VisitArrayPattern(ArrayPattern arrayPattern)
{
using (StartNodeObject(arrayPattern))
Member("elements", arrayPattern.Elements);
}
protected internal override void VisitArrayPattern(ArrayPattern arrayPattern)
{
VisitingArrayPattern?.Invoke(this, arrayPattern);
base.VisitArrayPattern(arrayPattern);
VisitedArrayPattern?.Invoke(this, arrayPattern);
}
protected override void VisitArrayPattern(ArrayPattern arrayPattern)
{
}
private static void HandleArrayPattern(Engine engine, ArrayPattern pattern, JsValue argument, LexicalEnvironment environment)
{
var obj = TypeConverter.ToObject(engine, argument);
ArrayOperations arrayOperations = null;
IIterator iterator = null;
if (obj.IsArrayLike)
{
arrayOperations = ArrayOperations.For(obj);
}
else
{
if (!obj.TryGetIterator(engine, out iterator))
{
ExceptionHelper.ThrowTypeError(engine);
return;
}
}
var completionType = CompletionType.Normal;
var close = false;
var done = false;
uint i = 0;
try
{
for (; i < pattern.Elements.Count; i++)
{
var left = pattern.Elements[(int)i];
if (left is null)
{
if (arrayOperations != null)
{
arrayOperations.TryGetValue(i, out _);
}
else
{
if (!ConsumeFromIterator(iterator, out _, out done))
{
break;
}
}
// skip assignment
continue;
}
if (left is Identifier identifier)
{
JsValue value;
if (arrayOperations != null)
{
arrayOperations.TryGetValue(i, out value);
}
else
{
if (!ConsumeFromIterator(iterator, out value, out done))
{
break;
}
}
AssignToIdentifier(engine, identifier.Name, value, environment);
}
else if (left is MemberExpression me)
{
close = true;
var reference = GetReferenceFromMember(engine, me);
JsValue value;
if (arrayOperations != null)
{
arrayOperations.TryGetValue(i, out value);
}
else
{
ConsumeFromIterator(iterator, out value, out done);
}
AssignToReference(engine, reference, value, environment);
}
else if (left is BindingPattern bindingPattern)
{
JsValue value;
if (arrayOperations != null)
{
arrayOperations.TryGetValue(i, out value);
}
else
{
iterator.TryIteratorStep(out var temp);
value = temp;
}
ProcessPatterns(engine, bindingPattern, value, environment);
}
else if (left is RestElement restElement)
{
close = true;
Reference reference = null;
if (restElement.Argument is MemberExpression memberExpression)
{
reference = GetReferenceFromMember(engine, memberExpression);
}
ArrayInstance array;
if (arrayOperations != null)
{
var length = arrayOperations.GetLength();
array = engine.Array.ConstructFast(length - i);
for (uint j = i; j < length; ++j)
{
arrayOperations.TryGetValue(j, out var indexValue);
array.SetIndexValue(j - i, indexValue, updateLength: false);
}
}
else
{
array = engine.Array.ConstructFast(0);
uint index = 0;
done = true;
do
{
if (!iterator.TryIteratorStep(out var item))
{
done = true;
break;
}
var value = item.Get(CommonProperties.Value);
array.SetIndexValue(index++, value, updateLength: false);
} while (true);
array.SetLength(index);
}
if (restElement.Argument is Identifier leftIdentifier)
{
AssignToIdentifier(engine, leftIdentifier.Name, array, environment);
}
else if (restElement.Argument is BindingPattern bp)
{
ProcessPatterns(engine, bp, array, environment);
}
else
{
AssignToReference(engine, reference, array, environment);
}
}
else if (left is AssignmentPattern assignmentPattern)
{
JsValue value;
if (arrayOperations != null)
{
arrayOperations.TryGetValue(i, out value);
}
else
{
ConsumeFromIterator(iterator, out value, out done);
}
if (value.IsUndefined())
{
var jintExpression = Build(engine, assignmentPattern.Right);
value = jintExpression.GetValue();
}
if (assignmentPattern.Left is Identifier leftIdentifier)
{
if (assignmentPattern.Right.IsFunctionWithName())
{
((FunctionInstance)value).SetFunctionName(new JsString(leftIdentifier.Name));
}
AssignToIdentifier(engine, leftIdentifier.Name, value, environment);
}
else if (assignmentPattern.Left is BindingPattern bp)
{
ProcessPatterns(engine, bp, value, environment);
}
}
else
{
ExceptionHelper.ThrowArgumentOutOfRangeException("pattern",
"Unable to determine how to handle array pattern element " + left);
break;
}
}
close = true;
}
catch
{
completionType = CompletionType.Throw;
throw;
}
finally
{
if (close && !done)
{
iterator?.Close(completionType);
}
}
}
