public void Parse_AliasInTernary()
{
ASTNode root = ExpressionParser.Parse("$item.isInDirectControl ? '1' : '2'");
OperatorNode node = AssertInstanceOfAndReturn <OperatorNode>(root);
Assert.AreEqual(OperatorType.TernaryCondition, node.operatorType);
MemberAccessExpressionNode left = AssertInstanceOfAndReturn <MemberAccessExpressionNode>(node.left);
}
protected override AssignmentState handleMemberAccess(MemberAccessExpressionNode memberAccess, HashSet <StatementNode> visited,
bool nested)
{
if (handleExpression(memberAccess.TargetObject, visited, true) == AssignmentState.Assigned)
{
return(AssignmentState.Assigned);
}
return(AssignmentState.NotAssigned);
}
public override PapyrusType VisitMemberAccessExpression(MemberAccessExpressionNode node)
{
if (node == null)
{
return(null);
}
return(Visit(node.AccessExpression));
}
public void Parse_InvokeAccessExpression_NoArgs()
{
ASTNode root = ExpressionParser.Parse("someProperty()");
Assert.IsInstanceOf <MemberAccessExpressionNode>(root);
MemberAccessExpressionNode node = (MemberAccessExpressionNode)root;
Assert.AreEqual(1, node.parts.Count);
Assert.IsInstanceOf <InvokeNode>(node.parts[0]);
}
public void Parse_SafeAccessor_Dot()
{
ASTNode root = ExpressionParser.Parse("instance?.property");
MemberAccessExpressionNode node = AssertInstanceOfAndReturn <MemberAccessExpressionNode>(root);
Assert.AreEqual(1, node.parts.Count);
Assert.AreEqual("instance", node.identifier);
Assert.IsInstanceOf <DotAccessNode>(node.parts[0]);
Assert.IsTrue(((DotAccessNode)node.parts[0]).isNullableAccess);
Assert.AreEqual("property", ((DotAccessNode)node.parts[0]).propertyName);
}
public void Parse_ArrayAccess_NestedArrayAccess()
{
ASTNode root = ExpressionParser.Parse("{rootContext[ rootContext[3] ]}");
Assert.IsInstanceOf <MemberAccessExpressionNode>(root);
MemberAccessExpressionNode node = (MemberAccessExpressionNode)root;
Assert.AreEqual("rootContext", node.identifier);
Assert.AreEqual(1, node.parts.Count);
Assert.IsInstanceOf <IndexNode>(node.parts[0]);
Assert.IsInstanceOf <MemberAccessExpressionNode>(((IndexNode)node.parts[0]).arguments[0]);
}
public void Parse_DotAccessExpression_Multiple()
{
ASTNode root = ExpressionParser.Parse("someProperty.someValue.someOtherValue.evenMore");
Assert.IsInstanceOf <MemberAccessExpressionNode>(root);
MemberAccessExpressionNode node = (MemberAccessExpressionNode)root;
Assert.AreEqual(3, node.parts.Count);
Assert.AreEqual("someProperty", node.identifier);
Assert.AreEqual("someValue", ((DotAccessNode)node.parts[0]).propertyName);
Assert.AreEqual("someOtherValue", ((DotAccessNode)node.parts[1]).propertyName);
Assert.AreEqual("evenMore", ((DotAccessNode)node.parts[2]).propertyName);
}
public void Parse_DotAccessExpression()
{
ASTNode root = ExpressionParser.Parse("someProperty.someValue");
Assert.IsInstanceOf <MemberAccessExpressionNode>(root);
MemberAccessExpressionNode node = (MemberAccessExpressionNode)root;
Assert.AreEqual(1, node.parts.Count);
DotAccessNode dotNode = node.parts[0] as DotAccessNode;
Assert.AreEqual("someValue", dotNode.propertyName);
Assert.AreEqual("someProperty", node.identifier);
}
public void Parse_PropertyAccessMixedArrayAccessWithInvoke()
{
ASTNode root = ExpressionParser.Parse("{rootContext()[1].property1.property2}");
Assert.IsInstanceOf <MemberAccessExpressionNode>(root);
MemberAccessExpressionNode node = (MemberAccessExpressionNode)root;
Assert.AreEqual("rootContext", node.identifier);
Assert.AreEqual(4, node.parts.Count);
Assert.IsInstanceOf <InvokeNode>(node.parts[0]);
Assert.IsInstanceOf <IndexNode>(node.parts[1]);
Assert.IsInstanceOf <DotAccessNode>(node.parts[2]);
Assert.IsInstanceOf <DotAccessNode>(node.parts[3]);
}
public void Parse_SafeAccessor_Index()
{
ASTNode root = ExpressionParser.Parse("instance?[1]");
MemberAccessExpressionNode node = AssertInstanceOfAndReturn <MemberAccessExpressionNode>(root);
Assert.AreEqual(1, node.parts.Count);
Assert.AreEqual("instance", node.identifier);
Assert.IsInstanceOf <IndexNode>(node.parts[0]);
IndexNode indexNode = (IndexNode)node.parts[0];
Assert.IsTrue(indexNode.isNullableAccess);
Assert.AreEqual(1, indexNode.arguments.Count);
Assert.IsInstanceOf <LiteralNode>(indexNode.arguments[0]);
}
public void Parse_InvokeAccessExpression_1Arg()
{
ASTNode root = ExpressionParser.Parse("someProperty(1)");
Assert.IsInstanceOf <MemberAccessExpressionNode>(root);
MemberAccessExpressionNode node = (MemberAccessExpressionNode)root;
Assert.AreEqual(1, node.parts.Count);
Assert.IsInstanceOf <InvokeNode>(node.parts[0]);
InvokeNode invokeNode = (InvokeNode)node.parts[0];
Assert.AreEqual(1, invokeNode.parameters.Count);
Assert.IsInstanceOf <LiteralNode>(invokeNode.parameters[0]);
}
public void Parse_TypePathExpression_WithGenerics()
{
ASTNode root = ExpressionParser.Parse("System.Collections.Generic.List<System.Tuple<int, System.Collections.Generic.List<string>>>.Value");
MemberAccessExpressionNode node = AssertInstanceOfAndReturn <MemberAccessExpressionNode>(root);
var t = typeof(System.Collections.Generic.List <System.Tuple <int, System.Collections.Generic.List <string> > >);
Assert.AreEqual("System", node.identifier);
Assert.AreEqual("Collections", AssertInstanceOfAndReturn <DotAccessNode>(node.parts[0]).propertyName);
Assert.AreEqual("Generic", AssertInstanceOfAndReturn <DotAccessNode>(node.parts[1]).propertyName);
Assert.AreEqual("List", AssertInstanceOfAndReturn <DotAccessNode>(node.parts[2]).propertyName);
GenericTypePathNode typeNode = AssertInstanceOfAndReturn <GenericTypePathNode>(node.parts[3]);
Assert.AreEqual(1, typeNode.genericPath.generics.Count);
Assert.AreEqual(typeof(Tuple <int, System.Collections.Generic.List <string> >), TypeProcessor.ResolveType(typeNode.genericPath.generics[0]));
}
public void Parse_Ternary_WithParenExpression()
{
ASTNode root = ExpressionParser.Parse("thing != null ? data.ToString() : 'Anything'}");
OperatorNode outerTernary = AssertOpNode(root, OperatorType.TernaryCondition);
OperatorNode outerCondition = AssertOpNode(outerTernary.left, OperatorType.NotEquals);
OperatorNode outerSelection = AssertOpNode(outerTernary.right, OperatorType.TernarySelection);
Assert.AreEqual("thing", AssertInstanceOfAndReturn <IdentifierNode>(outerCondition.left).name);
Assert.AreEqual("null", AssertInstanceOfAndReturn <LiteralNode>(outerCondition.right).rawValue);
MemberAccessExpressionNode access = AssertInstanceOfAndReturn <MemberAccessExpressionNode>(outerSelection.left);
LiteralNode anything = AssertInstanceOfAndReturn <LiteralNode>(outerSelection.right);
Assert.AreEqual(anything.rawValue, "Anything");
}
public void Parse_InvokeAccessExpression_2Arg_Chained()
{
ASTNode root = ExpressionParser.Parse("someProperty(1, something)()");
Assert.IsInstanceOf <MemberAccessExpressionNode>(root);
MemberAccessExpressionNode node = (MemberAccessExpressionNode)root;
Assert.AreEqual(2, node.parts.Count);
Assert.IsInstanceOf <InvokeNode>(node.parts[0]);
Assert.IsInstanceOf <InvokeNode>(node.parts[1]);
InvokeNode invokeNode = (InvokeNode)node.parts[0];
Assert.AreEqual(2, invokeNode.parameters.Count);
Assert.IsInstanceOf <LiteralNode>(invokeNode.parameters[0]);
Assert.IsInstanceOf <IdentifierNode>(invokeNode.parameters[1]);
}
protected override Void handleMemberAccess(MemberAccessExpressionNode memberAccess, Set <TypeInfo> dependencies, bool nested)
{
var info = memberAccess.getUserData(typeof(ExpressionInfo));
var member = info.getMember();
handleExpression(memberAccess.TargetObject, dependencies, nested);
if (member == null)
{
var type = info.Type;
if (type != null)
{
addDependencies(type, dependencies);
}
}
return(null);
}
public void Parse_ArrayAccess_RootContext_LiteralExpression()
{
ASTNode root = ExpressionParser.Parse("{rootContext[ 1 + 1 ]}");
Assert.IsInstanceOf <MemberAccessExpressionNode>(root);
MemberAccessExpressionNode node = (MemberAccessExpressionNode)root;
Assert.AreEqual("rootContext", node.identifier);
Assert.AreEqual(1, node.parts.Count);
Assert.IsInstanceOf <IndexNode>(node.parts[0]);
Assert.IsInstanceOf <OperatorNode>(((IndexNode)node.parts[0]).arguments[0]);
OperatorNode opNode = (OperatorNode)((IndexNode)node.parts[0]).arguments[0];
Assert.AreEqual(OperatorType.Plus, opNode.operatorType);
Assert.IsInstanceOf <LiteralNode>(opNode.left);
Assert.IsInstanceOf <LiteralNode>(opNode.right);
}
public static IEnumerable <PapyrusSymbol> GetReferencableSymbolsForMemberAccess(this MemberAccessExpressionNode memberAccessExpression)
{
var baseExpression = memberAccessExpression.BaseExpression;
var accessExpression = memberAccessExpression.AccessExpression;
var baseType = baseExpression.GetTypeOfExpression();
if (baseType is ComplexType asComplexType)
{
var functionCall = accessExpression?.GetDescendants(true).OfType <FunctionCallExpressionNode>().FirstOrDefault();
var isGlobalCall = functionCall != null && functionCall.IsGlobalCall;
// TODO: Unsure if this still needs to be done.
// If the accessExpression is null (we're at '.' without any identifier), we need to fall back to inferring whether
// or not this is a global call by looking at the base expression.
// If it is an identifier expression that resolves to a script type, then we know the member symbols are global only.
if (accessExpression == null && baseExpression is IdentifierExpressionNode accessAsIdentifier)
{
var referencedSymbol = accessAsIdentifier.Identifier.GetDeclaredOrReferencedSymbol();
if (referencedSymbol != null)
{
isGlobalCall = referencedSymbol.Kind == SymbolKinds.Script;
}
}
var typeSymbol = asComplexType.Symbol;
if (typeSymbol is ScriptSymbol asScriptSymbol)
{
var memberSymbols = asScriptSymbol.GetScriptMemberSymbols(
globalOnly: isGlobalCall,
declaredOnly: asScriptSymbol.SyntheticArrayType != null,
additionalNonGlobalKinds: memberAccessExpression.Parent is FunctionHeaderNode ? SymbolKinds.Event | SymbolKinds.CustomEvent : SymbolKinds.None);
if (memberAccessExpression.Parent is FunctionHeaderNode)
{
return(memberSymbols.Where(s => (s.Kind & SymbolKinds.Event) != 0 || (s.Kind & SymbolKinds.CustomEvent) != 0));
}
if (!isGlobalCall)
{
if (baseExpression.IsSelfIdentifierExpression())
{
return(memberSymbols.Where(s => (s.Kind & SymbolKinds.Function) != 0 || (s.Kind & SymbolKinds.Event) != 0 || (s.Kind & SymbolKinds.Property) != 0));
}
if (baseExpression.IsParentIdentifierExpression())
{
return(memberSymbols.Where(s => (s.Kind & SymbolKinds.Function) != 0 || (s.Kind & SymbolKinds.Event) != 0));
}
}
return(memberSymbols);
}
#if FALLOUT4
if (typeSymbol is StructSymbol asStructSymbol)
{
return(asStructSymbol.Children);
}
#endif
}
return(Enumerable.Empty <PapyrusSymbol>());
}
