public Diagnostic[] GetDiagnostics()
{
var res = _diagnostics.ToArray();
_diagnostics.ClearAndTruncate();
return(res);
}
internal void EnsureClientTypeVersion()
{
if (ClientTypeVersion != 0)
{
return;
}
EnsureKnownLastPersistedVersion();
var props = _clientType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
var fields = new StructList <TableFieldInfo>();
fields.Reserve((uint)props.Length);
foreach (var pi in props)
{
if (pi.GetCustomAttributes(typeof(NotStoredAttribute), true).Length != 0)
{
continue;
}
if (pi.GetIndexParameters().Length != 0)
{
continue;
}
fields.Add(TableFieldInfo.Build(Name, pi, _tableInfoResolver.FieldHandlerFactory, FieldHandlerOptions.None));
}
var tvi = new TableVersionInfo(fields.ToArray());
if (LastPersistedVersion == 0)
{
_tableVersions.TryAdd(1, tvi);
ClientTypeVersion = 1;
}
else
{
var last = _tableVersions.GetOrAdd(LastPersistedVersion, (ver, tableInfo) => tableInfo._tableInfoResolver.LoadTableVersionInfo(tableInfo._id, ver, tableInfo.Name), this);
if (TableVersionInfo.Equal(last, tvi))
{
_tableVersions[LastPersistedVersion] = tvi; // tvi was build from real types and not loaded so it is more exact
ClientTypeVersion = LastPersistedVersion;
}
else
{
_tableVersions.TryAdd(LastPersistedVersion + 1, tvi);
ClientTypeVersion = LastPersistedVersion + 1;
}
}
}
public TypeInf(Type type, IFieldHandlerFactory fieldHandlerFactory)
{
OriginalType = type;
_name = type.Name;
var methodInfs = new StructList <MethodInf>();
var propertyInfs = new StructList <PropertyInf>();
if (type.IsSubclassOf(typeof(Delegate)))
{
var method = type.GetMethod(nameof(Action.Invoke));
if (IsMethodSupported(method, fieldHandlerFactory))
{
methodInfs.Add(new MethodInf(method, fieldHandlerFactory));
}
}
else
{
var methods = type.GetMethods();
foreach (var method in methods)
{
var methodBase = method.GetBaseDefinition();
if (methodBase.DeclaringType == typeof(object))
{
continue;
}
if (methodBase.GetBaseDefinition().DeclaringType == typeof(IDisposable))
{
continue;
}
if (!methodBase.IsPublic)
{
continue;
}
if (!IsMethodSupported(method, fieldHandlerFactory))
{
continue;
}
methodInfs.Add(new MethodInf(method, fieldHandlerFactory));
}
var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (var property in properties)
{
if (!property.CanRead || !property.CanWrite)
{
continue;
}
if (property.GetCustomAttributes(typeof(NotStoredAttribute), true).Length != 0)
{
continue;
}
if (property.GetIndexParameters().Length != 0)
{
continue;
}
if (property.GetGetMethod() == null)
{
continue;
}
if (property.GetSetMethod() == null)
{
continue;
}
if (!fieldHandlerFactory.TypeSupported(property.PropertyType))
{
continue;
}
propertyInfs.Add(new PropertyInf(property, fieldHandlerFactory));
}
}
_methodInfs = methodInfs.ToArray();
_propertyInfs = propertyInfs.ToArray();
}
private bool ParseDeclaration(ref ASTNode node)
{
AttributeNode attrNode = null;
LightList <AttributeNode> attributes = LightList <AttributeNode> .Get();
while (ParseAttribute(ref attrNode))
{
attributes.Add(attrNode);
if (tokenStream.Current != ExpressionTokenType.ArrayAccessOpen)
{
break;
}
}
if (attributes.size == 0)
{
LightList <AttributeNode> .Release(ref attributes);
}
if (tokenStream.Current != ExpressionTokenType.Identifier)
{
return(false);
}
// modifiers? -> returnType -> name -> signature -> openBrace * closeBrace
tokenStream.Save();
bool isStatic = false;
if (tokenStream.Current == "static")
{
isStatic = true;
tokenStream.Advance();
}
ExpressionParser parser = new ExpressionParser(tokenStream);
StructList <LambdaArgument> signature = null;
TypeLookup typeLookup = default;
if (!parser.ParseTypePath(ref typeLookup))
{
goto fail;
}
tokenStream.Set(parser.GetTokenPosition());
parser.Release(false);
if (tokenStream.Current != ExpressionTokenType.Identifier)
{
goto fail;
}
string name = tokenStream.Current.value;
tokenStream.Advance();
// if semi colon then we have a field!
if (tokenStream.Current == ExpressionTokenType.SemiColon)
{
tokenStream.Advance();
node = new FieldNode()
{
name = name,
isStatic = isStatic,
attributes = attributes,
typeLookup = typeLookup
};
return(true);
}
if (tokenStream.Current != ExpressionTokenType.ParenOpen)
{
goto fail;
}
signature = StructList <LambdaArgument> .Get();
if (tokenStream.NextTokenIs(ExpressionTokenType.ParenClose))
{
tokenStream.Advance(2);
}
else
{
int matchingIndex = tokenStream.FindMatchingIndex(ExpressionTokenType.ParenOpen, ExpressionTokenType.ParenClose);
if (matchingIndex == -1)
{
goto fail;
}
TokenStream subStream = tokenStream.AdvanceAndReturnSubStream(matchingIndex);
subStream.Advance();
tokenStream.Advance();
if (!ExpressionParser.ParseSignature(subStream, signature))
{
goto fail;
}
for (int i = 0; i < signature.size; i++)
{
if (signature.array[i].type == null)
{
throw new ParseException($"When defining a method you must specify a type for all arguments. Found identifier {signature.array[i].identifier} but no type was given.");
}
}
}
if (tokenStream.Current != ExpressionTokenType.ExpressionOpen)
{
goto fail;
}
BlockNode block = ParseBlock();
node = new MethodNode()
{
body = block,
returnTypeLookup = typeLookup,
attributes = attributes,
name = name,
isStatic = isStatic,
signatureList = signature != null?signature.ToArray() : s_EmptySignature
};
StructList <LambdaArgument> .Release(ref signature);
parser.Release(false);
return(true);
fail:
{
tokenStream.Restore();
parser.Release(false);
typeLookup.Release();
signature?.Release();
return(false);
}
}