public static NameReference Create(TypeMutability overrideMutability, IExpression prefix, string name, IEnumerable <INameReference> arguments, EntityInstance target, bool isLocal) { var result = new NameReference(overrideMutability, prefix, BrowseMode.None, null, name, arguments?.Select(it => new TemplateArgument(it)), ExpressionReadMode.ReadRequired, isRoot: false); if (target != null) { result.Binding.Set(new[] { new BindingMatch(target, isLocal) }); } return(result); }
public static bool TryGetSingleType(this INameReference @this, out NameReference nameReference, out EntityInstance typeInstance) { nameReference = @this as NameReference; if (nameReference == null) { typeInstance = null; return(false); } else { typeInstance = nameReference.Evaluation.Components.Cast <EntityInstance>(); return(true); } }
public void SetConstraint(TemplateConstraint constraint) { if (this.Constraint != null) { throw new InvalidOperationException(); } this.Constraint = constraint ?? TemplateConstraint.Create(NameReference.Create(this.Name), null, null, null, null); this.AssociatedType = TypeDefinition.CreateTypeParameter(this); this.InstanceOf = AssociatedType.GetInstance(overrideMutability: TypeMutability.None, translation: null, lifetime: Lifetime.Timeless); this.attachPostConstructor(); }
public static NameReference Create(params string[] parts) { if (parts.Length == 0) { throw new ArgumentException(); } else if (parts.Length == 1) { return(NameReference.Create(parts.Single())); } else { return(NameReference.Create(NameReference.Create(parts.SkipTail(1).ToArray()), parts.Last())); } }
private TemplateConstraint( NameReference name, EntityModifier constraintModifier, IEnumerable <FunctionDefinition> hasFunctions, IEnumerable <NameReference> inherits, IEnumerable <NameReference> baseOf) { if (name == null) { throw new ArgumentNullException(); } this.Name = name; this.Modifier = constraintModifier ?? EntityModifier.None; this.HasFunctions = (hasFunctions ?? Enumerable.Empty <FunctionDefinition>()).StoreReadOnly(); this.InheritsNames = (inherits ?? Enumerable.Empty <NameReference>()).StoreReadOnly(); this.BaseOfNames = (baseOf ?? Enumerable.Empty <NameReference>()).StoreReadOnly(); this.attachPostConstructor(); }
public static NameReference ReferenceNameReference(string name) { return(ReferenceNameReference(NameReference.Create(name))); }
public static NameReference ReferenceNameReference(INameReference name) { return(NameReference.Create(NameReference.Root, NameFactory.ReferenceTypeName, name)); }
public static NameReference PointerNameReference(INameReference name, TypeMutability mutability = TypeMutability.None) { return(NameReference.Create(mutability, NameReference.Root, NameFactory.PointerTypeName, name)); }
public static NameReference RegexNameReference() { return(NameReference.Create(TextNamespaceReference(), NameFactory.RegexTypeName)); }
public static NameReference CaptureNameReference() { return(NameReference.Create(TextNamespaceReference(), NameFactory.CaptureTypeName)); }
public static NameReference ExceptionNameReference() { return(NameReference.Create(SystemNamespaceReference(), NameFactory.ExceptionTypeName)); }
public static NameReference ITupleMutableNameReference(params INameReference[] templateParamNames) { return(NameReference.Create(TypeMutability.ForceMutable, CollectionsNamespaceReference(), ITupleTypeName, templateParamNames)); }
public static NameReference ITupleNameReference(params INameReference[] templateParamNames) { return(NameReference.Create(CollectionsNamespaceReference(), ITupleTypeName, templateParamNames)); }
public static NameReference TupleFactoryReference() { return(NameReference.Create(CollectionsNamespaceReference(), TupleTypeName)); }
public static NameReference ConcatReference() { return(NameReference.Create(CollectionsNamespaceReference(), ConcatFunctionName)); }
public static NameReference OrderingNameReference() { return(NameReference.Create(SystemNamespaceReference(), NameFactory.OrderingTypeName)); }
public static NameReference OptionNameReference(LifetimeScope lifetimeScope, INameReference name, TypeMutability mutability = TypeMutability.None) { return(NameReference.Create(mutability, SystemNamespaceReference(), lifetimeScope, NameFactory.OptionTypeName, name)); }
public static NameReference IObjectNameReference(TypeMutability overrideMutability = TypeMutability.None) { return(NameReference.Create(overrideMutability, NameReference.Root, IObjectTypeName)); }
public static NameReference TypeInfoPointerNameReference() { return(PointerNameReference(NameReference.Create(SystemNamespaceReference(), NameFactory.TypeInfoTypeName))); }
public static NameReference SystemNamespaceReference() { return(NameReference.Create(NameReference.Root, SystemNamespace)); }
public static NameReference MatchNameReference() { return(NameReference.Create(TextNamespaceReference(), NameFactory.MatchTypeName)); }
public static NameReference CollectionsNamespaceReference() { return(NameReference.Create(SystemNamespaceReference(), CollectionsNamespace)); }
public static NameReference Real64NameReference() { return(NameReference.Create(NameReference.Root, NameFactory.Real64TypeName)); }
public static NameReference IoNamespaceReference() { return(NameReference.Create(SystemNamespaceReference(), IoNamespace)); }
public static NameReference PointerNameReference(string typeName) { return(PointerNameReference(NameReference.Create(typeName))); }
public static NameReference ConcurrencyNamespaceReference() { return(NameReference.Create(SystemNamespaceReference(), ConcurrencyNamespace)); }
public static NameReference ReferenceNameReference(LifetimeScope lifetimeScope, INameReference name) { return(NameReference.Create(NameReference.Root, lifetimeScope, NameFactory.ReferenceTypeName, name)); }
public static NameReference Utf8StringNameReference(TypeMutability mutability = TypeMutability.None) { return(NameReference.Create(mutability, SystemNamespaceReference(), NameFactory.Utf8StringTypeName)); }
internal static INameReference ShouldBeThisNameReference(string typeName, TypeMutability mutability = TypeMutability.None) { // todo: Skila1 supported the notion of dynamic "this type", Skila-3 should also have it // so once we have time to do it this method will help us fast track all the use cases to replace return(NameReference.Create(mutability, typeName)); }
public static NameReference IComparableNameReference(TypeMutability mutability = TypeMutability.None) { return(NameReference.Create(mutability, SystemNamespaceReference(), NameFactory.IComparableTypeName)); }