public SymbolResolverVisitor(SymbolTable symtable, TypeInferrer inferrer)
{
this.SymbolTable = symtable;
this.Inferrer = inferrer;
this.unarySymbolResolver = new UnarySymbolResolver();
this.binarySymbolResolver = new BinarySymbolResolver();
this.assignmentSymbolResolver = new AssignmentSymbolResolver();
this.constantSymbolResolver = new ConstantSymbolResolver();
this.variableSymbolResolver = new VariableSymbolResolver();
this.blockSymbolResolver = new BlockSymbolResolver();
this.declarationSymbolResolver = new DeclarationSymbolResolver();
this.primitiveSymbolResolver = new PrimitiveSymbolResolver();
this.accessorSymbolResolver = new AccessorSymbolResolver();
this.ifSymbolResolver = new IfSymbolResolver();
this.whileSymbolResolver = new WhileSymbolResolver();
this.forSymbolResolver = new ForSymbolResolver();
this.breakSymbolResolver = new BreakSymbolResolver();
this.continueSymbolResolver = new ContinueSymbolResolver();
this.callSymbolResolver = new CallableSymbolResolver();
this.funcDeclSymbolResolver = new FunctionSymbolResolver();
this.objectSymbolResolver = new ObjectSymbolResolver();
this.objectPropertySymbolResolver = new ObjectPropertySymbolResolver();
this.tupleSymbolResolver = new TupleSymbolResolver();
this.returnSymbolResolver = new ReturnSymbolResolver();
this.nullCoalescingSymbolResolver = new NullCoalescingSymbolResolver();
this.classSymbolResolver = new ClassSymbolResolver();
this.classPropertySymbolResolver = new ClassPropertySymbolResolver();
this.classConstantSymbolResolver = new ClassConstantSymbolResolver();
this.classMethodSymbolResolver = new ClassMethodSymbolResolver();
}
private bool IsValidExtensionType(IType actualType, IType extensionType, IExtensionEnabled extension)
{
if (TypeCompatibilityRules.IsAssignableFrom(extensionType, actualType))
{
return(true);
}
// Check for a valid generic extension
IMethod method = extension as IMethod;
if (method == null || method.GenericInfo == null)
{
return(false);
}
System.Collections.Generic.List <IGenericParameter> genericParameters = new System.Collections.Generic.List <IGenericParameter>(GenericsServices.FindGenericParameters(extensionType));
if (genericParameters.Count == 0)
{
return(false);
}
TypeInferrer inferrer = new TypeInferrer(genericParameters);
inferrer.Infer(extensionType, actualType);
return(inferrer.FinalizeInference());
}
private Boolean TryGetElementStyle(IVisualElement element,
String styleName,
out IStyle style)
{
var styleType = TypeInferrer.GetTypeFromClearName(styleName);
if (styleType == null)
{
style = default !;
BestType DetermineBestTypes(params object[] values)
{
var bestTypes = TypeInferrer.DetermineBestTypes(Data(values));
return(bestTypes[_key]);
}
public IFileConfig UpdateFileConfig(FileInfo file, IFileConfig prevConfig)
{
var csvConfig = prevConfig as CsvConfig ?? new CsvConfig
{
Delimiter = GetDefaultDelimiter(),
};
csvConfig.BestTypes = GetBestTypes();
return csvConfig;
Dictionary<string, BestType> GetBestTypes()
{
using var fileReader = file.OpenText();
using var reader = GetTextReader(fileReader);
var record = new List<string>();
var q = from rec in reader.ReadCsvWithHeader(
delimiter: csvConfig.Delimiter,
textQualifier: csvConfig.TextQualifier,
record: record)
select
from k in rec.Keys
let value = rec.ContainsKey(k) ? rec[k] : string.Empty
select (k, value);
return TypeInferrer.DetermineBestTypes(q, new TypeInferrer.Options { UserParser = CreateUserParser() });
TypeInferrer.TryParseValue CreateUserParser()
{
var trueSet = csvConfig.TrueStrings?.GetHashSet();
var falseSet = csvConfig.FalseStrings?.GetHashSet();
var nullSet = csvConfig.NullStrings?.GetHashSet();
return (string v, out ParsedValue x) =>
{
if (trueSet?.Contains(v) == true || falseSet?.Contains(v) == true)
{
x = ParsedValue.Bool;
return true;
}
if (nullSet?.Contains(v) == true)
{
x = ParsedValue.EmptyString;
return true;
}
x = default;
return false;
};
}
}
TextReader GetTextReader(StreamReader fileReader)
{
if (string.IsNullOrWhiteSpace(csvConfig.Header))
return fileReader;
return new CompositeTextReader(new TextReader[]
{
new StringReader(csvConfig.Header.Trim() + Environment.NewLine),
fileReader
});
}
char GetDefaultDelimiter() => file.Extension.ToLowerInvariant() switch
{
".tsv" => '\t',
_ => ','
};
}
public SymbolTable(TypeInferrer typeInferrer)
{
// Create the @global scope and set it as the current scope
this.Global = this.CurrentScope = new Block("@global");
this.TypeInferrer = typeInferrer;
}
internal static IType GetTypeSymbol(SymbolTable symtable, TypeInferrer inferrer, Token token)
{
// If the token has a reference to an identifier, the types come from the explicit annotation
if (token.Type == TokenType.Identifier)
{
if (token.Value == BuiltinType.Bool.GetName())
{
return(new Primitive(BuiltinType.Bool, symtable.CurrentScope));
}
if (token.Value == BuiltinType.Char.GetName())
{
return(new Primitive(BuiltinType.Char, symtable.CurrentScope));
}
if (token.Value == BuiltinType.Int.GetName())
{
return(new Primitive(BuiltinType.Int, symtable.CurrentScope));
}
if (token.Value == BuiltinType.Float.GetName())
{
return(new Primitive(BuiltinType.Float, symtable.CurrentScope));
}
if (token.Value == BuiltinType.Double.GetName())
{
return(new Primitive(BuiltinType.Double, symtable.CurrentScope));
}
if (token.Value == BuiltinType.Decimal.GetName())
{
return(new Primitive(BuiltinType.Decimal, symtable.CurrentScope));
}
if (token.Value == BuiltinType.String.GetName())
{
return(new Primitive(BuiltinType.String, symtable.CurrentScope));
}
// Support complex types:
if (token.Value == "func" || token.Value == "tuple")
{
return(inferrer?.NewAnonymousType());
}
if (symtable.HasVariableSymbol(token.Value))
{
/*var typeInfo = symtable.Get(token.Value).ITypeSymbol;
* if (typeInfo.Type is Class ctype)
* return new ITypeSymbol(new ClassInstance(ctype));
* return typeInfo;*/
}
/*var type = new ClassInstance(new Class(token.Value));
* symtable.AddUnresolvedType(type.Class.ClassName, token);
* return new ITypeSymbol(type);*/
throw new Exception($"Unknown type '{token.Value}'");
}
// Getting the type from a literal value or an 'auto' property
switch (token.Type)
{
case TokenType.Boolean:
return(new Primitive(BuiltinType.Bool, symtable.CurrentScope));
case TokenType.Char:
return(new Primitive(BuiltinType.Char, symtable.CurrentScope));
case TokenType.Integer:
return(new Primitive(BuiltinType.Int, symtable.CurrentScope));
case TokenType.Float:
return(new Primitive(BuiltinType.Float, symtable.CurrentScope));
case TokenType.Double:
return(new Primitive(BuiltinType.Double, symtable.CurrentScope));
case TokenType.Decimal:
return(new Primitive(BuiltinType.Decimal, symtable.CurrentScope));
case TokenType.String:
return(new Primitive(BuiltinType.String, symtable.CurrentScope));
case TokenType.Variable:
return(new None());
//return inferrer?.NewAnonymousType(); // Auto
}
throw new SymbolException($"Unrecognized literal {token.Type}");
}
internal static BuiltinType GetType(SymbolTable symtable, TypeInferrer inferrer, Token token)
{
return(GetTypeSymbol(symtable, inferrer, token).BuiltinType);
}
