private UstExprs.Expression VisitClassExpression(ClassExpression classExpression)
{
var className = classExpression.Id != null
? VisitIdentifier(classExpression.Id)
: null;
var baseTypes = new Collections.List <UstTokens.TypeToken>();
if (classExpression.SuperClass != null)
{
if (VisitExpression(classExpression.SuperClass) is UstTokens.TypeToken superClassTypeToken)
{
baseTypes.Add(superClassTypeToken);
}
}
var properties = VisitClassBody(classExpression.Body);
var typeDeclaration = new TypeDeclaration(null, className, properties, GetTextSpan(classExpression))
{
BaseTypes = baseTypes
};
return(typeDeclaration.ToExpressionIfRequired());
}
protected override void VisitClassExpression(ClassExpression expression)
{
CS.IndentInOut(false,
"ClassExpression",
() =>
{
var characters = new SortedSet <int>();
foreach (var part in expression.Choices)
{
characters.UnionWith(part.Values);
}
var array = string.Join(",", characters.Select(c => CharRep.InCSharp(c)));
var staticValue = GL.Local($"_{Cfg.CL("character-class")}");
GL.Ln($"private static int[] {staticValue} = new int[] {{{array}}};");
CS.Ln($"// {staticValue} = {{{array}}}");
var cond = expression.Negated
? "< 0"
: ">= 0";
var check = characters.Count > 8
? $"_current => Array.BinarySearch({staticValue}, _current) {cond}"
: $"_current => Array.IndexOf({staticValue}, _current) {cond}";
CS.Ln($"{Locals.Result} = {Cfg.MatchPredicate}({Cfg.CurName}, {check});");
});
}
public Discovery()
{
Config = new Configuration();
Classes = new ClassExpression(Config);
Methods = new MethodExpression(Config);
Parameters = new ParameterSourceExpression(Config);
}
public void TestClassExpressionGetProperties()
{
// Act
var properties = ClassExpression.GetProperties <ClassExpressionTestClass>();
// Assert
Assert.AreEqual(2, properties.Count());
}
protected override void VisitClassExpression(ClassExpression classExpression)
{
using (StartNodeObject(classExpression))
{
Member("id", classExpression.Id);
Member("superClass", classExpression.SuperClass);
Member("body", classExpression.Body);
}
}
private ClassExpression Class(INode node)
{
Debug.Assert(node.Name == "class" && node.Count == 2);
var invert = node[0].Count == 1;
var ranges = node[1].Children.Select(SingleOrRange).ToArray();
return(ClassExpression.From(node, invert, ranges));
}
protected override void VisitClassExpression(ClassExpression expression)
{
var start = parsers.Count;
base.VisitClassExpression(expression);
var parser = new Choice(Pop(start));
parsers.Add(parser);
}
protected override void VisitClassExpression(ClassExpression classExpression)
{
// class name identifier skipped
if (classExpression.SuperClass != null)
{
Visit(classExpression.SuperClass);
}
Visit(classExpression.Body);
}
public void ParseSimpleClassCommand()
{
Parser parser = new Parser("class Dog\na=1\nend");
var expected = new ClassExpression(new NameExpression("Dog"), new AssignExpression("a", new ConstantExpression(1)));
var result = parser.ParseCommand();
Assert.IsNotNull(result);
Assert.AreEqual(expected, result);
Assert.IsNull(parser.ParseCommand());
}
public void ParseQualifiedClassCommand()
{
Parser parser = new Parser("class Animals::Dog\na=1\nend");
var expected = new ClassExpression(new DoubleColonExpression(new NameExpression("Animals"), "Dog"), new AssignExpression("a", new ConstantExpression(1)));
var result = parser.ParseCommand();
Assert.IsNotNull(result);
Assert.AreEqual(expected, result);
Assert.IsNull(parser.ParseCommand());
}
public Convention()
{
Config = new Configuration();
Classes = new ClassExpression(Config);
Methods = new MethodExpression(Config);
Parameters = new ParameterSourceExpression(Config);
CaseExecution = new CaseBehaviorExpression(Config);
FixtureExecution = new FixtureBehaviorExpression(Config);
ClassExecution = new ClassBehaviorExpression(Config);
HideExceptionDetails = new AssertionLibraryExpression(Config);
}
public Convention()
{
Config = new Configuration();
Classes = new ClassExpression(Config);
Methods = new MethodExpression(Config);;
Parameters = new ParameterSourceExpression(Config);
CaseExecution = new CaseBehaviorExpression(Config);
FixtureExecution = new FixtureBehaviorExpression(Config);
ClassExecution = new ClassBehaviorExpression(Config);
HideExceptionDetails = new AssertionLibraryExpression(Config);
}
protected override void VisitClassExpression(ClassExpression expression)
{
void Write()
{
Writer.Write("[");
foreach (var choice in expression.Choices)
{
VisitExpression(choice);
}
Writer.Write("]");
}
LexSpaced(expression, Write);
}
public void TestMySqlConnectionDeleteAllAsyncViaTableNameViaPrimaryKeys()
{
// Setup
var tables = Database.CreateCompleteTables(10);
var primaryKeys = ClassExpression.GetEntitiesPropertyValues <CompleteTable, object>(tables, e => e.Id);
using (var connection = new MySqlConnection(Database.ConnectionString).EnsureOpen())
{
// Act
var result = connection.DeleteAllAsync(ClassMappedNameCache.Get <CompleteTable>(), primaryKeys).Result;
// Assert
Assert.AreEqual(tables.Count(), result);
}
}
public void TestClassExpressionGetPropertiesAndValues()
{
// Setup
var entity = GetEntities(1).First();
// Act
var propertyValues = ClassExpression.GetPropertiesAndValues <ClassExpressionTestClass>(entity);
// Assert
Assert.AreEqual(2, propertyValues.Count());
Assert.AreEqual("Id", propertyValues.ElementAt(0).Name);
Assert.AreEqual(entity.Id, propertyValues.ElementAt(0).Value);
Assert.AreEqual("Property1", propertyValues.ElementAt(1).Name);
Assert.AreEqual(entity.Property1, propertyValues.ElementAt(1).Value);
}
public void TestSqLiteConnectionDeleteAllAsyncViaPrimaryKeys()
{
using (var connection = new SqliteConnection(Database.ConnectionString))
{
// Setup
var tables = Database.CreateCompleteTables(10, connection);
var primaryKeys = ClassExpression.GetEntitiesPropertyValues <CompleteTable, object>(tables, e => e.Id);
// Act
var result = connection.DeleteAllAsync <CompleteTable>(primaryKeys).Result;
// Assert
Assert.AreEqual(tables.Count(), result);
}
}
public void TestSqLiteConnectionDeleteAllViaTableNameViaPrimaryKeys()
{
using (var connection = new SqliteConnection(Database.ConnectionStringMDS))
{
// Setup
var tables = Database.CreateMdsCompleteTables(10, connection);
var primaryKeys = ClassExpression.GetEntitiesPropertyValues <MdsCompleteTable, object>(tables, e => e.Id);
// Act
var result = connection.DeleteAll(ClassMappedNameCache.Get <MdsCompleteTable>(), primaryKeys);
// Assert
Assert.AreEqual(tables.Count(), result);
}
}
public void TestMySqlConnectionDeleteAllViaPrimaryKeysBeyondLimits()
{
// Setup
var tables = Database.CreateCompleteTables(5000);
var primaryKeys = ClassExpression.GetEntitiesPropertyValues <CompleteTable, object>(tables, e => e.Id);
using (var connection = new MySqlConnection(Database.ConnectionString).EnsureOpen())
{
// Act
var result = connection.DeleteAll <CompleteTable>(primaryKeys);
// Assert
Assert.AreEqual(tables.Count(), result);
}
}
public void TestClassExpressionGetEntitiesPropertyValuesViaField()
{
// Setup
var entities = GetEntities(10).AsList();
// Act
var propertyValues = ClassExpression.GetEntitiesPropertyValues <ClassExpressionTestClass, string>(entities, new Field("Property1"));
// Assert
Assert.AreEqual(entities.Count(), propertyValues.Count());
for (var i = 0; i < entities.Count(); i++)
{
var entity = entities.ElementAt(i);
Assert.AreEqual(entity.Property1, propertyValues.ElementAt(i));
}
}
public void Equals()
{
ClassExpression expr1 = new ClassExpression(new NameExpression("foo"), new ConstantExpression(1));
ClassExpression expr2 = new ClassExpression(new NameExpression("bar"), new ConstantExpression(1));
ClassExpression expr3 = new ClassExpression(new NameExpression("foo"), new ConstantExpression(2));
ClassExpression expr4 = new ClassExpression(new NameExpression("foo"), new ConstantExpression(1));
Assert.IsTrue(expr1.Equals(expr4));
Assert.IsTrue(expr4.Equals(expr1));
Assert.AreEqual(expr1.GetHashCode(), expr4.GetHashCode());
Assert.IsFalse(expr1.Equals(null));
Assert.IsFalse(expr1.Equals(123));
Assert.IsFalse(expr1.Equals(expr2));
Assert.IsFalse(expr2.Equals(expr1));
Assert.IsFalse(expr1.Equals(expr3));
Assert.IsFalse(expr3.Equals(expr1));
}
public void DefineSimpleClass()
{
Machine machine = new Machine();
Context context = machine.RootContext;
StringWriter writer = new StringWriter();
context.Self.Class.SetInstanceMethod("puts", new PutsFunction(writer));
ClassExpression expr = new ClassExpression(new NameExpression("Dog"), new CallExpression("puts", new IExpression[] { new ConstantExpression(123) }));
var result = expr.Evaluate(context);
Assert.IsNull(result);
var value = context.GetValue("Dog");
Assert.IsInstanceOfType(value, typeof(DynamicClass));
Assert.AreEqual(value, context.GetValue("Dog"));
Assert.AreEqual("123\r\n", writer.ToString());
}
public void TestSqlConnectionDeleteAllForInheritedViaPrimary()
{
// Setup
var entities = Helper.CreateInheritedIdentityTables(10);
using (var connection = new SqlConnection(Database.ConnectionStringForRepoDb))
{
// Act
connection.InsertAll <InheritedIdentityTable>(entities);
// Act
var deleteResult = connection.DeleteAll <InheritedIdentityTable>(
ClassExpression.GetEntitiesPropertyValues <InheritedIdentityTable, object>(entities, "Id"));
// Assert
Assert.AreEqual(entities.Count(), deleteResult);
Assert.AreEqual(0, connection.CountAll <InheritedIdentityTable>());
}
}
private static ClassExpression Class(INode node)
{
var parts = new List <ClassPartExpression>();
foreach (var part in node.Children.Skip(1))
{
switch (part.Name)
{
case "range":
parts.Add(ClassRangeExpression.From(part,
Char.ConvertToUtf32(DecodeChar(part[0]), 0),
Char.ConvertToUtf32(DecodeChar(part[1]), 0)));
break;
default:
parts.Add(ClassCharExpression.From(part, Char.ConvertToUtf32(DecodeChar(part), 0)));
break;
}
}
return(ClassExpression.From(node, node[0].Count != 0, parts));
}
public virtual void VisitClassExpression(ClassExpression classExpression)
{
}
public virtual InterfaceList VisitInterfaceReferenceList(InterfaceList interfaces, Class declaringClass){
if (interfaces == null) return null;
bool allowClass = declaringClass != null && declaringClass.BaseClassExpression == null;
TrivialHashtable interfaceAlreadySeen = new TrivialHashtable();
for (int i = 0, n = interfaces.Count; i < n; i++) {
Interface iface = (Interface)this.VisitInterfaceReference(interfaces[i]);
if (iface != null && interfaceAlreadySeen[iface.UniqueKey] != null){
this.HandleError(interfaces[i], Error.DuplicateInterfaceInBaseList, this.GetTypeName(iface));
interfaces[i] = null;
}else{
if (iface != null && iface.ObsoleteAttribute != null)
this.CheckForObsolesence(interfaces[i], iface);
InterfaceExpression ifExpr = interfaces[i] as InterfaceExpression;
if (ifExpr != null){
if (i == 0 && allowClass){
ClassExpression cExpr = new ClassExpression(ifExpr.Expression, ifExpr.TemplateArguments, ifExpr.SourceContext);
cExpr.DeclaringType = declaringClass;
this.AddNodePositionAndInfo(ifExpr.Expression, cExpr, IdentifierContexts.TypeContext);
}else
this.AddNodePositionAndInfo(ifExpr.Expression, ifExpr, IdentifierContexts.TypeContext);
}
interfaces[i] = iface;
if (iface == null) continue;
interfaceAlreadySeen[iface.UniqueKey] = iface;
}
}
return interfaces;
}
public static ClassExpression IsBddStyleClassNameOrEndsWithTests(this ClassExpression expr)
{
return(expr.Where(type => type.Name.EndsWith("Tests") || type.Name.StartsWith("When")));
}
public static ClassExpression ConstructorDoesntHaveArguments(this ClassExpression filter)
{
return(filter.Where(t => t.GetConstructors(BindingFlags.Public | BindingFlags.Instance)
.All(x => x.GetParameters().Length == 0)));
}
public static ClassExpression ConstructorHasArguments(this ClassExpression filter)
{
return(filter.Where(t => t.GetConstructors(BindingFlags.Public | BindingFlags.Instance)
.Any(x => x.GetParameters().Any())));
}
protected override void WalkClassExpression(ClassExpression classExpression)
{
this.Set(classExpression, "string");
}
public override TypeNode VisitTypeReference(TypeNode type)
{
if (type == null)
{
return(null);
}
Class cl = type as Class;
if (cl != null)
{
this.VisitTypeReference(cl.BaseClass);
}
if (this.MembersToFind[type.UniqueKey] != null)
{
this.FoundMembers[type.UniqueKey] = type;
if (!this.insideMethodBody)
{
this.AllReferencesAreConfinedToMethodBodies = false;
}
return(type);
}
switch (type.NodeType)
{
case NodeType.ArrayType:
ArrayType arrType = (ArrayType)type;
this.VisitTypeReference(arrType.ElementType);
return(type);
case NodeType.DelegateNode: {
FunctionType ftype = type as FunctionType;
if (ftype == null)
{
goto default;
}
this.VisitTypeReference(ftype.ReturnType);
this.VisitParameterList(ftype.Parameters);
return(type);
}
case NodeType.Pointer:
Pointer pType = (Pointer)type;
this.VisitTypeReference(pType.ElementType);
return(type);
case NodeType.Reference:
Reference rType = (Reference)type;
this.VisitTypeReference(rType.ElementType);
return(type);
case NodeType.TupleType: {
TupleType tType = (TupleType)type;
MemberList members = tType.Members;
int n = members == null ? 0 : members.Count;
for (int i = 0; i < n; i++)
{
Field f = members[i] as Field;
if (f == null)
{
continue;
}
this.VisitTypeReference(f.Type);
}
return(type);
}
case NodeType.TypeIntersection:
TypeIntersection tIntersect = (TypeIntersection)type;
this.VisitTypeReferenceList(tIntersect.Types);
return(type);
case NodeType.TypeUnion:
TypeUnion tUnion = (TypeUnion)type;
this.VisitTypeReferenceList(tUnion.Types);
return(type);
case NodeType.ArrayTypeExpression:
ArrayTypeExpression aExpr = (ArrayTypeExpression)type;
this.VisitTypeReference(aExpr.ElementType);
return(type);
case NodeType.BoxedTypeExpression:
BoxedTypeExpression bExpr = (BoxedTypeExpression)type;
this.VisitTypeReference(bExpr.ElementType);
return(type);
case NodeType.ClassExpression:
ClassExpression cExpr = (ClassExpression)type;
this.VisitExpression(cExpr.Expression);
this.VisitTypeReferenceList(cExpr.TemplateArguments);
return(type);
case NodeType.ClassParameter:
case NodeType.TypeParameter:
return(type);
case NodeType.ConstrainedType:
ConstrainedType conType = (ConstrainedType)type;
this.VisitTypeReference(conType.UnderlyingType);
this.VisitExpression(conType.Constraint);
return(type);
case NodeType.FlexArrayTypeExpression:
FlexArrayTypeExpression flExpr = (FlexArrayTypeExpression)type;
this.VisitTypeReference(flExpr.ElementType);
return(type);
case NodeType.FunctionTypeExpression:
FunctionTypeExpression ftExpr = (FunctionTypeExpression)type;
this.VisitParameterList(ftExpr.Parameters);
this.VisitTypeReference(ftExpr.ReturnType);
return(type);
case NodeType.InvariantTypeExpression:
InvariantTypeExpression invExpr = (InvariantTypeExpression)type;
this.VisitTypeReference(invExpr.ElementType);
return(type);
case NodeType.InterfaceExpression:
InterfaceExpression iExpr = (InterfaceExpression)type;
this.VisitExpression(iExpr.Expression);
this.VisitTypeReferenceList(iExpr.TemplateArguments);
return(type);
case NodeType.NonEmptyStreamTypeExpression:
NonEmptyStreamTypeExpression neExpr = (NonEmptyStreamTypeExpression)type;
this.VisitTypeReference(neExpr.ElementType);
return(type);
case NodeType.NonNullTypeExpression:
NonNullTypeExpression nnExpr = (NonNullTypeExpression)type;
this.VisitTypeReference(nnExpr.ElementType);
return(type);
case NodeType.NonNullableTypeExpression:
NonNullableTypeExpression nbExpr = (NonNullableTypeExpression)type;
this.VisitTypeReference(nbExpr.ElementType);
return(type);
case NodeType.NullableTypeExpression:
NullableTypeExpression nuExpr = (NullableTypeExpression)type;
this.VisitTypeReference(nuExpr.ElementType);
return(type);
case NodeType.OptionalModifier:
case NodeType.RequiredModifier:
TypeModifier modType = (TypeModifier)type;
this.VisitTypeReference(modType.ModifiedType);
this.VisitTypeReference(modType.Modifier);
return(type);
case NodeType.PointerTypeExpression:
PointerTypeExpression pExpr = (PointerTypeExpression)type;
this.VisitTypeReference(pExpr.ElementType);
return(type);
case NodeType.ReferenceTypeExpression:
ReferenceTypeExpression rExpr = (ReferenceTypeExpression)type;
this.VisitTypeReference(rExpr.ElementType);
return(type);
case NodeType.StreamTypeExpression:
StreamTypeExpression sExpr = (StreamTypeExpression)type;
this.VisitTypeReference(sExpr.ElementType);
return(type);
case NodeType.TupleTypeExpression:
TupleTypeExpression tuExpr = (TupleTypeExpression)type;
this.VisitFieldList(tuExpr.Domains);
return(type);
case NodeType.TypeExpression:
TypeExpression tExpr = (TypeExpression)type;
this.VisitExpression(tExpr.Expression);
this.VisitTypeReferenceList(tExpr.TemplateArguments);
return(type);
case NodeType.TypeIntersectionExpression:
TypeIntersectionExpression tiExpr = (TypeIntersectionExpression)type;
this.VisitTypeReferenceList(tiExpr.Types);
return(type);
case NodeType.TypeUnionExpression:
TypeUnionExpression tyuExpr = (TypeUnionExpression)type;
this.VisitTypeReferenceList(tyuExpr.Types);
return(type);
default:
if (type.Template != null && type.TemplateArguments != null)
{
this.VisitTypeReference(type.Template);
this.VisitTypeReferenceList(type.TemplateArguments);
}
return(type);
}
}
protected virtual MemberList GetMembers(int line, int col, ClassExpression cExpr, Scope scope){
if (cExpr == null) return null;
MemberList members;
QualifiedIdentifier qual = cExpr.Expression as QualifiedIdentifier;
if (qual != null)
members = this.GetMembers(line, col, qual, scope);
else
members = this.languageService.GetTypesNamespacesAndPrefixes(scope, false, false);
if (members == null) return null;
return this.GetClassesAndInterfacesAndNamespacesThatContainThem(members, cExpr.DeclaringType);
}
public virtual Class VisitClassExpression(ClassExpression cexpr){
if (cexpr == null) return null;
int numTemplArgs = cexpr.TemplateArgumentExpressions == null ? 0 : cexpr.TemplateArgumentExpressions.Count;
TypeNode bt = this.LookupType(cexpr.Expression, false, numTemplArgs);
if (bt == null){
this.HandleTypeExpected(cexpr.Expression);
return null;
}
Class c = bt as Class;
if (c != null){
if (cexpr.TemplateArguments != null){
cexpr.TemplateArguments = this.VisitTypeReferenceList(cexpr.TemplateArguments);
TypeNode ti = c.GetTemplateInstance(this.currentType, cexpr.TemplateArguments);
ti.TemplateExpression = cexpr;
this.AddTemplateInstanceToList(ti);
return (Class)ti;
}else
return c;
}else{
return null;
}
}
protected override void WalkClassExpression(ClassExpression classExpression)
{
this.zeroWidth[classExpression] = false;
}
public override TypeNode VisitTypeReference(TypeNode type)
{ //TODO: break up this method
if (type == null)
{
return(null);
}
TypeNodeList pars = this.pars;
TypeNodeList args = this.args;
switch (type.NodeType)
{
case NodeType.ArrayType:
ArrayType arrType = (ArrayType)type;
TypeNode elemType = this.VisitTypeReference(arrType.ElementType);
if (elemType == arrType.ElementType || elemType == null)
{
return(arrType);
}
if (arrType.IsSzArray())
{
return(elemType.GetArrayType(1));
}
return(elemType.GetArrayType(arrType.Rank, arrType.Sizes, arrType.LowerBounds));
case NodeType.DelegateNode:
{
FunctionType ftype = type as FunctionType;
if (ftype == null)
{
goto default;
}
TypeNode referringType = ftype.DeclaringType == null ? this.CurrentType : this.VisitTypeReference(ftype.DeclaringType);
return(FunctionType.For(this.VisitTypeReference(ftype.ReturnType), this.VisitParameterList(ftype.Parameters), referringType));
}
case NodeType.Pointer:
Pointer pType = (Pointer)type;
elemType = this.VisitTypeReference(pType.ElementType);
if (elemType == pType.ElementType || elemType == null)
{
return(pType);
}
return(elemType.GetPointerType());
case NodeType.Reference:
Reference rType = (Reference)type;
elemType = this.VisitTypeReference(rType.ElementType);
if (elemType == rType.ElementType || elemType == null)
{
return(rType);
}
return(elemType.GetReferenceType());
case NodeType.ArrayTypeExpression:
ArrayTypeExpression aExpr = (ArrayTypeExpression)type;
aExpr.ElementType = this.VisitTypeReference(aExpr.ElementType);
return(aExpr);
case NodeType.BoxedTypeExpression:
BoxedTypeExpression bExpr = (BoxedTypeExpression)type;
bExpr.ElementType = this.VisitTypeReference(bExpr.ElementType);
return(bExpr);
case NodeType.ClassExpression:
{
ClassExpression cExpr = (ClassExpression)type;
cExpr.Expression = this.VisitTypeExpression(cExpr.Expression);
//Could happen if the expression is a template parameter
if (cExpr.Expression is Literal lit)
{
return(lit.Value as TypeNode);
}
cExpr.TemplateArguments = this.VisitTypeReferenceList(cExpr.TemplateArguments);
return(cExpr);
}
case NodeType.ClassParameter:
case NodeType.TypeParameter:
int key = type.UniqueKey;
for (int i = 0, n = pars == null ? 0 : pars.Count, m = args == null ? 0 : args.Count; i < n && i < m; i++)
{
//^ assert pars != null && args != null;
TypeNode tp = pars[i];
if (tp == null)
{
continue;
}
if (tp.UniqueKey == key)
{
return(args[i]);
}
if (tp.Name.UniqueIdKey == type.Name.UniqueIdKey && (tp is ClassParameter && type is TypeParameter))
{
//This shouldn't really happen, but in practice it does. Hack past it.
return(args[i]);
}
}
return(type);
case NodeType.FlexArrayTypeExpression:
FlexArrayTypeExpression flExpr = (FlexArrayTypeExpression)type;
flExpr.ElementType = this.VisitTypeReference(flExpr.ElementType);
return(flExpr);
case NodeType.FunctionTypeExpression:
FunctionTypeExpression ftExpr = (FunctionTypeExpression)type;
ftExpr.Parameters = this.VisitParameterList(ftExpr.Parameters);
ftExpr.ReturnType = this.VisitTypeReference(ftExpr.ReturnType);
return(ftExpr);
case NodeType.InvariantTypeExpression:
InvariantTypeExpression invExpr = (InvariantTypeExpression)type;
invExpr.ElementType = this.VisitTypeReference(invExpr.ElementType);
return(invExpr);
case NodeType.InterfaceExpression:
InterfaceExpression iExpr = (InterfaceExpression)type;
if (iExpr.Expression == null)
{
goto default;
}
iExpr.Expression = this.VisitTypeExpression(iExpr.Expression);
iExpr.TemplateArguments = this.VisitTypeReferenceList(iExpr.TemplateArguments);
return(iExpr);
case NodeType.NonEmptyStreamTypeExpression:
NonEmptyStreamTypeExpression neExpr = (NonEmptyStreamTypeExpression)type;
neExpr.ElementType = this.VisitTypeReference(neExpr.ElementType);
return(neExpr);
case NodeType.NonNullTypeExpression:
NonNullTypeExpression nnExpr = (NonNullTypeExpression)type;
nnExpr.ElementType = this.VisitTypeReference(nnExpr.ElementType);
return(nnExpr);
case NodeType.NonNullableTypeExpression:
NonNullableTypeExpression nbExpr = (NonNullableTypeExpression)type;
nbExpr.ElementType = this.VisitTypeReference(nbExpr.ElementType);
return(nbExpr);
case NodeType.NullableTypeExpression:
NullableTypeExpression nuExpr = (NullableTypeExpression)type;
nuExpr.ElementType = this.VisitTypeReference(nuExpr.ElementType);
return(nuExpr);
case NodeType.OptionalModifier:
{
TypeModifier modType = (TypeModifier)type;
TypeNode modifiedType = this.VisitTypeReference(modType.ModifiedType);
TypeNode modifierType = this.VisitTypeReference(modType.Modifier);
if (modifiedType == null || modifierType == null)
{
return(type);
}
return(OptionalModifier.For(modifierType, modifiedType));
}
case NodeType.RequiredModifier:
{
TypeModifier modType = (TypeModifier)type;
TypeNode modifiedType = this.VisitTypeReference(modType.ModifiedType);
TypeNode modifierType = this.VisitTypeReference(modType.Modifier);
if (modifiedType == null || modifierType == null)
{
Debug.Fail(""); return(type);
}
return(RequiredModifier.For(modifierType, modifiedType));
}
case NodeType.OptionalModifierTypeExpression:
OptionalModifierTypeExpression optmodType = (OptionalModifierTypeExpression)type;
optmodType.ModifiedType = this.VisitTypeReference(optmodType.ModifiedType);
optmodType.Modifier = this.VisitTypeReference(optmodType.Modifier);
return(optmodType);
case NodeType.RequiredModifierTypeExpression:
RequiredModifierTypeExpression reqmodType = (RequiredModifierTypeExpression)type;
reqmodType.ModifiedType = this.VisitTypeReference(reqmodType.ModifiedType);
reqmodType.Modifier = this.VisitTypeReference(reqmodType.Modifier);
return(reqmodType);
case NodeType.PointerTypeExpression:
PointerTypeExpression pExpr = (PointerTypeExpression)type;
pExpr.ElementType = this.VisitTypeReference(pExpr.ElementType);
return(pExpr);
case NodeType.ReferenceTypeExpression:
ReferenceTypeExpression rExpr = (ReferenceTypeExpression)type;
rExpr.ElementType = this.VisitTypeReference(rExpr.ElementType);
return(rExpr);
case NodeType.StreamTypeExpression:
StreamTypeExpression sExpr = (StreamTypeExpression)type;
sExpr.ElementType = this.VisitTypeReference(sExpr.ElementType);
return(sExpr);
case NodeType.TupleTypeExpression:
TupleTypeExpression tuExpr = (TupleTypeExpression)type;
tuExpr.Domains = this.VisitFieldList(tuExpr.Domains);
return(tuExpr);
case NodeType.TypeExpression:
{
TypeExpression tExpr = (TypeExpression)type;
tExpr.Expression = this.VisitTypeExpression(tExpr.Expression);
if (tExpr.Expression is Literal)
{
return(type);
}
tExpr.TemplateArguments = this.VisitTypeReferenceList(tExpr.TemplateArguments);
return(tExpr);
}
case NodeType.TypeIntersectionExpression:
TypeIntersectionExpression tiExpr = (TypeIntersectionExpression)type;
tiExpr.Types = this.VisitTypeReferenceList(tiExpr.Types);
return(tiExpr);
case NodeType.TypeUnionExpression:
TypeUnionExpression tyuExpr = (TypeUnionExpression)type;
tyuExpr.Types = this.VisitTypeReferenceList(tyuExpr.Types);
return(tyuExpr);
default:
TypeNode declaringType = this.VisitTypeReference(type.DeclaringType);
if (declaringType != null)
{
Identifier tname = type.Name;
if (type.Template != null && type.IsGeneric)
{
tname = type.Template.Name;
}
TypeNode nt = declaringType.GetNestedType(tname);
if (nt != null)
{
TypeNodeList arguments = type.TemplateArguments;
type = nt;
if (TargetPlatform.UseGenerics)
{
if (arguments != null && arguments.Count > 0 && nt.ConsolidatedTemplateParameters != null && nt.ConsolidatedTemplateParameters.Count > 0)
{
type = nt.GetTemplateInstance(this.TargetModule, this.CurrentType, declaringType, arguments);
}
}
}
}
if (type.Template != null && (type.ConsolidatedTemplateParameters == null || type.ConsolidatedTemplateParameters.Count == 0))
{
if (!type.IsNotFullySpecialized && (!type.IsNormalized ||
(this.CurrentType != null && type.DeclaringModule == this.CurrentType.DeclaringModule)))
{
return(type);
}
// Type is a template instance, but some of its arguments were themselves parameters.
// See if any of these parameters are to be specialized by this specializer.
bool mustSpecializeFurther = false;
TypeNodeList targs = type.TemplateArguments;
int numArgs = targs == null ? 0 : targs.Count;
if (targs != null)
{
targs = new TypeNodeList(targs);
for (int i = 0; i < numArgs; i++)
{
TypeNode targ = targs[i];
if (targ is ITypeParameter tparg)
{
for (int j = 0, np = pars == null ? 0 : pars.Count, m = args == null ? 0 : args.Count; j < np && j < m; j++)
{
//^ assert pars != null && args != null;
if (TargetPlatform.UseGenerics)
{
if (!(pars[j] is ITypeParameter par))
{
continue;
}
if (tparg == par || (tparg.ParameterListIndex == par.ParameterListIndex && tparg.DeclaringMember == par.DeclaringMember))
{
targ = this.args[j];
break;
}
}
else
{
if (targ == pars[j])
{
targ = this.args[j];
break;
}
}
}
}
else
{
if (targ != type)
{
targ = this.VisitTypeReference(targ);
}
if (targ == type)
{
continue;
}
}
mustSpecializeFurther |= targs[i] != targ;
targs[i] = targ;
}
}
if (targs == null || !mustSpecializeFurther)
{
return(type);
}
return(type.Template.GetTemplateInstance(this.TargetModule, this.CurrentType, declaringType, targs));
}
TypeNodeList tPars = type.TemplateParameters;
if (tPars == null || tPars.Count == 0)
{
return(type); //Not a parameterized type. No need to get an instance.
}
TypeNodeList tArgs = new TypeNodeList();
for (int i = 0, n = tPars.Count; i < n; i++)
{
TypeNode tPar = tPars[i];
tArgs.Add(tPar); //Leave parameter in place if there is no match
if (tPar == null || tPar.Name == null)
{
continue;
}
int idKey = tPar.Name.UniqueIdKey;
for (int j = 0, m = pars == null ? 0 : pars.Count, k = args == null ? 0 : args.Count; j < m && j < k; j++)
{
//^ assert pars != null && args != null;
TypeNode par = pars[j];
if (par == null || par.Name == null)
{
continue;
}
if (par.Name.UniqueIdKey == idKey)
{
tArgs[i] = args[j];
break;
}
}
}
return(type.GetTemplateInstance(this.TargetModule, this.CurrentType, this.VisitTypeReference(type.DeclaringType), tArgs));
}
}
public virtual void VisitBaseClassReference(Class Class){
if (Class == null) return;
if (Class.Name.UniqueIdKey == StandardIds.CapitalObject.UniqueIdKey && Class.Namespace.UniqueIdKey == StandardIds.System.UniqueIdKey) {
Class.BaseClass = null; Class.BaseClassExpression = null;
return;
}
if (Class.PartiallyDefines is Class && ((Class)Class.PartiallyDefines).BaseClass == null)
this.VisitBaseClassReference((Class)Class.PartiallyDefines);
TypeNodeList partialTypes = Class.IsDefinedBy;
if (partialTypes != null){
for (int i = 0, n = partialTypes == null ? 0 : partialTypes.Count; i < n; i++){
Class partialClass = partialTypes[i] as Class;
if (partialClass == null || partialClass.BaseClass == SystemTypes.Object) continue;
partialClass.PartiallyDefines = null; //Stop recursion
this.VisitBaseClassReference(partialClass);
partialClass.PartiallyDefines = Class;
if (partialClass.BaseClass == SystemTypes.Object) continue;
Class.BaseClass = partialClass.BaseClass;
return;
}
}
//Visit Class.BaseClass, but guard against doing it twice
//(this routine can get called when visiting a derived class that occurs lexically before Class)
if (Class.BaseClassExpression == Class) return; //Still resolving the base class. This is a recursive call due to a recursive type argument.
if (Class.BaseClass != null) {
ClassExpression cExpr = Class.BaseClass as ClassExpression;
if (cExpr == null) return; //Been here before and found a base class
this.VisitBaseClassReference(Class, true);
return;
}
//Leaving the BaseClass null is the convention for asking that the first expression in the interface list be treated as the base class, if possible.
//If not possible, the convention is to set BaseClass equal to SystemTypes.Object.
InterfaceList interfaces = Class.Interfaces;
InterfaceList interfaceExpressions = Class.InterfaceExpressions;
if (interfaces != null && interfaces.Count > 0){
Interface iface = interfaces[0];
InterfaceExpression ifExpr = iface as InterfaceExpression;
if (ifExpr != null){
ClassExpression cExpr = new ClassExpression(ifExpr.Expression, ifExpr.TemplateArguments, ifExpr.SourceContext);
Class.BaseClass = Class.BaseClassExpression = cExpr;
if (this.VisitBaseClassReference(Class, false)){
//The first expression is not meant as an interface, remove it from the list
int n = interfaces.Count-1;
InterfaceList actualInterfaces = new InterfaceList(n);
InterfaceList actualInterfaceExpressions = new InterfaceList(n);
for (int i = 0; i < n; i++) {
actualInterfaces.Add(interfaces[i+1]);
if (interfaceExpressions != null)
actualInterfaceExpressions.Add(interfaceExpressions[i+1]);
}
Class.Interfaces = actualInterfaces;
if (interfaceExpressions != null)
Class.InterfaceExpressions = actualInterfaceExpressions;
}else{
Class.BaseClass = SystemTypes.Object; Class.BaseClassExpression = null;
}
}else{
Class.BaseClass = SystemTypes.Object; Class.BaseClassExpression = null;
}
}else{
Class.BaseClass = SystemTypes.Object; Class.BaseClassExpression = null;
}
if (Class.BaseClass != null && Class.BaseClass != SystemTypes.Object) {
this.VisitBaseClassReference(Class.BaseClass.Template as Class);
this.VisitBaseClassReference(Class.BaseClass);
}
}
