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));
}
