Esempio n. 1
0
        /// <summary>
        /// propertyName parameter must be of type generic list
        /// </summary>
        public ISyntaxNode Create(ISyntaxNode concept, string propertyName, Type child)
        {
            ISyntaxNode item = (ISyntaxNode)Activator.CreateInstance(child);

            item.Parent = concept;

            IList        list;
            PropertyInfo property = concept.GetType().GetProperty(propertyName);

            if (property.IsOptional())
            {
                IOptional optional = (IOptional)property.GetValue(concept);
                list = (IList)optional.Value;
                if (list == null)
                {
                    Type listType = property.PropertyType.GetProperty("Value").PropertyType;
                    list           = (IList)Activator.CreateInstance(listType);
                    optional.Value = list;
                }
            }
            else
            {
                list = (IList)property.GetValue(concept);
                if (list == null)
                {
                    Type listType = property.PropertyType;
                    list = (IList)Activator.CreateInstance(listType);
                    property.SetValue(concept, list);
                }
            }

            list.Add(item);
            return(item);
        }
Esempio n. 2
0
        private IAssemblyConcept SelectAssemblyReference(ISyntaxNode concept, string propertyName, Visual control)
        {
            // get scope provider
            IScopeProvider scopeProvider = SyntaxTreeManager.GetScopeProvider(concept.GetType());

            if (scopeProvider == null)
            {
                return(null);
            }

            // get references in the scope
            IEnumerable <ISyntaxNode> scope = scopeProvider.Scope(concept, propertyName);

            if (scope == null || scope.Count() == 0)
            {
                return(null);
            }

            // build tree view
            TreeNodeViewModel viewModel = SyntaxNodeExtensions.BuildAssemblySelectorTree(scope);

            // open dialog window
            PopupWindow dialog = new PopupWindow(control, viewModel);

            _ = dialog.ShowDialog();
            if (dialog.Result == null)
            {
                return(null);
            }

            // return selected reference
            return(dialog.Result.NodePayload as IAssemblyConcept);
        }
Esempio n. 3
0
        public static PropertyInfo GetPropertyInfo(this ISyntaxNode @this, string propertyName)
        {
            Type         metadata = @this.GetType();
            PropertyInfo property = metadata.GetProperty(propertyName);

            return(property);
        }
Esempio n. 4
0
 private static VisitorAction Leave(
     ISyntaxNodeVisitor visitor,
     ISyntaxNode node,
     ISyntaxNode parent,
     IReadOnlyList <object> path,
     IReadOnlyList <ISyntaxNode> ancestors)
 {
     if (_leaveVisitors.TryGetValue(node.GetType(), out IntVisitorFn v))
     {
         return(v.Invoke(visitor, node, parent, path, ancestors));
     }
     return(VisitorAction.Default);
 }
        private IConceptLayout GetLayout(ISyntaxNode concept)
        {
            if (concept == null)
            {
                throw new ArgumentNullException(nameof(concept));
            }
            Type type = concept.GetType();

            if (_layouts.TryGetValue(type, out IConceptLayout layout))
            {
                return(layout);
            }
            return(null);
        }
        public IdentifierNodeViewModel(ISyntaxNodeViewModel owner, ISyntaxNode model) : base(owner, model)
        {
            if (model == null)
            {
                throw new ArgumentNullException(nameof(model));
            }

            Type metadata = model.GetType();

            if (!metadata.GetInterfaces().Contains(typeof(IIdentifiable)))
            {
                throw new InvalidOperationException("Interface \"IIdentifiable\" is not found!");
            }

            _identifiable = (IIdentifiable)model;
        }
Esempio n. 7
0
        public static ISyntaxNode Ancestor <T>(this ISyntaxNode @this)
        {
            Type        ancestorType = typeof(T);
            ISyntaxNode ancestor     = @this.Parent;

            while (ancestor != null)
            {
                if (ancestor.GetType() != ancestorType)
                {
                    ancestor = ancestor.Parent;
                }
                else
                {
                    break;
                }
            }
            return(ancestor);
        }
Esempio n. 8
0
        private static (object, FunnyType) ParseSyntaxNode(ISyntaxNode syntaxNode)
        {
            if (syntaxNode == null)
            {
                throw new ArgumentException();
            }
            if (syntaxNode is ConstantSyntaxNode constant)
            {
                return(ParseConstant(constant));
            }
            if (syntaxNode is GenericIntSyntaxNode intGeneric)
            {
                return(ParseGenericIntConstant(intGeneric));
            }
            if (syntaxNode is ArraySyntaxNode array)
            {
                var       items       = new List <object>(array.Expressions.Count);
                FunnyType?unifiedType = null;
                foreach (var child in array.Expressions)
                {
                    var(value, childVarType) = ParseSyntaxNode(child);
                    if (!unifiedType.HasValue)
                    {
                        unifiedType = childVarType;
                    }
                    else if (unifiedType != childVarType)
                    {
                        unifiedType = FunnyType.Anything;
                    }

                    items.Add(value);
                }

                if (!items.Any())
                {
                    return(new object[0], FunnyType.ArrayOf(FunnyType.Anything));
                }
                return(items.ToArray(), FunnyType.ArrayOf(unifiedType.Value));
            }
            throw new NotSupportedException($"syntax node {syntaxNode.GetType().Name} is not supported");
        }
Esempio n. 9
0
        public static TypeConstraint GetTypeConstraints(IEnumerable <LanguageConcept> languages, ISyntaxNode concept, string propertyName)
        {
            if (concept == null)
            {
                throw new ArgumentNullException(nameof(concept));
            }
            if (string.IsNullOrWhiteSpace(propertyName))
            {
                throw new ArgumentNullException(nameof(propertyName));
            }

            Type         metadata = concept.GetType();
            PropertyInfo property = metadata.GetProperty(propertyName);

            if (property == null)
            {
                throw new ArgumentOutOfRangeException(nameof(property));
            }

            return(GetTypeConstraints(languages, property));
        }
Esempio n. 10
0
        protected override ISyntaxVisitorAction Enter(
            ISyntaxNode node,
            ISyntaxVisitorContext context)
        {
            switch (node.Kind)
            {
            case SyntaxKind.Name:
                return(Enter((NameNode)node, context));

            case SyntaxKind.Document:
                return(Enter((DocumentNode)node, context));

            case SyntaxKind.OperationDefinition:
                return(Enter((OperationDefinitionNode)node, context));

            case SyntaxKind.VariableDefinition:
                return(Enter((VariableDefinitionNode)node, context));

            case SyntaxKind.Variable:
                return(Enter((VariableNode)node, context));

            case SyntaxKind.SelectionSet:
                return(Enter((SelectionSetNode)node, context));

            case SyntaxKind.Field:
                return(Enter((FieldNode)node, context));

            case SyntaxKind.Argument:
                return(Enter((ArgumentNode)node, context));

            case SyntaxKind.FragmentSpread:
                return(Enter((FragmentSpreadNode)node, context));

            case SyntaxKind.InlineFragment:
                return(Enter((InlineFragmentNode)node, context));

            case SyntaxKind.FragmentDefinition:
                return(Enter((FragmentDefinitionNode)node, context));

            case SyntaxKind.Directive:
                return(Enter((DirectiveNode)node, context));

            case SyntaxKind.NamedType:
                return(Enter((NamedTypeNode)node, context));

            case SyntaxKind.ListType:
                return(Enter((ListTypeNode)node, context));

            case SyntaxKind.NonNullType:
                return(Enter((NonNullTypeNode)node, context));

            case SyntaxKind.ListValue:
                return(Enter((ListValueNode)node, context));

            case SyntaxKind.ObjectValue:
                return(Enter((ObjectValueNode)node, context));

            case SyntaxKind.ObjectField:
                return(Enter((ObjectFieldNode)node, context));

            case SyntaxKind.BooleanValue:
            case SyntaxKind.EnumValue:
            case SyntaxKind.FloatValue:
            case SyntaxKind.IntValue:
            case SyntaxKind.NullValue:
            case SyntaxKind.StringValue:
                return(Enter((IValueNode)node, context));

            case SyntaxKind.SchemaDefinition:
                return(Enter((SchemaDefinitionNode)node, context));

            case SyntaxKind.OperationTypeDefinition:
                return(Enter((OperationTypeDefinitionNode)node, context));

            case SyntaxKind.ScalarTypeDefinition:
                return(Enter((ScalarTypeDefinitionNode)node, context));

            case SyntaxKind.ObjectTypeDefinition:
                return(Enter((ObjectTypeDefinitionNode)node, context));

            case SyntaxKind.FieldDefinition:
                return(Enter((FieldDefinitionNode)node, context));

            case SyntaxKind.InputValueDefinition:
                return(Enter((InputValueDefinitionNode)node, context));

            case SyntaxKind.InterfaceTypeDefinition:
                return(Enter((InterfaceTypeDefinitionNode)node, context));

            case SyntaxKind.UnionTypeDefinition:
                return(Enter((UnionTypeDefinitionNode)node, context));

            case SyntaxKind.EnumTypeDefinition:
                return(Enter((EnumTypeDefinitionNode)node, context));

            case SyntaxKind.EnumValueDefinition:
                return(Enter((EnumValueDefinitionNode)node, context));

            case SyntaxKind.InputObjectTypeDefinition:
                return(Enter((InputObjectTypeDefinitionNode)node, context));

            case SyntaxKind.DirectiveDefinition:
                return(Enter((DirectiveDefinitionNode)node, context));

            case SyntaxKind.SchemaExtension:
                return(Enter((SchemaExtensionNode)node, context));

            case SyntaxKind.ScalarTypeExtension:
                return(Enter((ScalarTypeExtensionNode)node, context));

            case SyntaxKind.ObjectTypeExtension:
                return(Enter((ObjectTypeExtensionNode)node, context));

            case SyntaxKind.InterfaceTypeExtension:
                return(Enter((InterfaceTypeExtensionNode)node, context));

            case SyntaxKind.UnionTypeExtension:
                return(Enter((UnionTypeExtensionNode)node, context));

            case SyntaxKind.EnumTypeExtension:
                return(Enter((EnumTypeExtensionNode)node, context));

            case SyntaxKind.InputObjectTypeExtension:
                return(Enter((InputObjectTypeExtensionNode)node, context));

            default:
                throw new NotSupportedException(node.GetType().FullName);
            }
        }
Esempio n. 11
0
        /// <summary>
        /// Gets property type constraints for the given concept's property (derived from SyntaxNode only)
        /// </summary>
        public static IEnumerable <ISyntaxNode> GetPropertyTypeConstraints(ISyntaxNode concept, string propertyName)
        {
            List <ISyntaxNode> constraints = new List <ISyntaxNode>();

            Type                          metadata             = concept.GetType();
            PropertyInfo                  property             = metadata.GetProperty(propertyName);
            TypeConstraintAttribute       typeConstraint       = property.GetCustomAttribute <TypeConstraintAttribute>();
            SimpleTypeConstraintAttribute simpleTypeConstraint = property.GetCustomAttribute <SimpleTypeConstraintAttribute>();

            if (simpleTypeConstraint != null)
            {
                constraints.AddRange(SimpleTypes.References);
            }
            if (typeConstraint != null)
            {
                foreach (Type type in typeConstraint.Types)
                {
                    if (type.IsAbstract)
                    {
                        foreach (Type subclass in GetSubclassesOfType(type))
                        {
                            constraints.Add((ISyntaxNode)Activator.CreateInstance(subclass));
                        }
                    }
                    else
                    {
                        if (type.IsClass && type.IsSubclassOf(typeof(SyntaxNode)))
                        {
                            constraints.Add((ISyntaxNode)Activator.CreateInstance(type));
                        }
                    }
                }
            }

            if (property.IsOptional())
            {
                property = property.PropertyType.GetProperty("Value");
            }
            Type propertyType;

            if (property.IsList()) // looking for List<T>
            {
                propertyType = property.PropertyType.GenericTypeArguments[0];
            }
            else
            {
                propertyType = property.PropertyType;
            }

            if (propertyType.IsAbstract)
            {
                foreach (Type subclass in GetSubclassesOfType(propertyType))
                {
                    constraints.Add((ISyntaxNode)Activator.CreateInstance(subclass));
                }
            }
            else
            {
                if (propertyType.IsClass && propertyType.IsSubclassOf(typeof(SyntaxNode)))
                {
                    constraints.Add((ISyntaxNode)Activator.CreateInstance(propertyType));
                }
            }

            return(constraints);
        }
Esempio n. 12
0
        public static void SetConceptProperty(ISyntaxNode concept, string propertyName, object value)
        {
            PropertyInfo property = concept.GetPropertyInfo(propertyName);

            if (property == null)
            {
                throw new NullReferenceException($"Property \"{propertyName}\" of the \"{concept.GetType()}\" type is not found!");
            }
            if (property.IsRepeatable())
            {
                throw new InvalidOperationException($"Property \"{propertyName}\" can not be repeatable!");
            }

            if (property.IsOptional())
            {
                IOptional optional = (IOptional)property.GetValue(concept);
                optional.Value = value;
            }
            else
            {
                property.SetValue(concept, value);
            }
        }