protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext)
{
var prefixList = this.Objectexp.Symbol.GetExpressions(packagesContext, expContext);
if (prefixList.Length != 1)
{
throw new SyntaxException(string.Format("Cannot resolve symbol {0}", this.MemberValue), this.Member.Line, this.Member.Column);
}
var prefix = prefixList[0];
switch (prefix.Classify)
{
case ExpressionType.Value:
if (prefix.Type.Name == Type.Function.Name && prefix.Type.PackageName == Type.Function.PackageName)
{
throw new SyntaxException(string.Format("Cannot resolve global symbol {0}", this.MemberValue), this.Member.Line, this.Member.Column);
}
if (prefix.Type == Type.Table || prefix.Type == Type.Any)
{
return(new[] { new Expression()
{
Classify = ExpressionType.Value, Type = Type.Any
} });
}
var c = packagesContext.GetClass(prefix.Type.Name);
if (c == null)
{
throw new SyntaxException(string.Format("Cannot resolve symbol {0}", this.MemberValue), this.Member.Line, this.Member.Column);
}
return(this.GetExpTypeAsVariable(packagesContext, expContext, c));
case ExpressionType.Class:
if (prefix.Type == Type.Any)
{
this.accessType = "";
return(this.GetExpressionsWithValue(Type.Any));
}
if (prefix.Type == Type.Table)
{
return(this.GetExpressionsWithValue(Type.Any));
}
c = packagesContext.GetClass(prefix.Type.Name);
if (c == null)
{
throw new SyntaxException(string.Format("Cannot resolve symbol {0}", this.MemberValue), this.Member.Line, this.Member.Column);
}
return(this.GetExpTypeAsClass(packagesContext, expContext, c));
case ExpressionType.This:
return(this.GetExpTypeAsVariable(packagesContext, expContext, expContext.ClassContext));
case ExpressionType.Super:
if (expContext.ParentContext != null && expContext.ParentContext is Class)
{
return(this.GetExpTypeAsVariable(packagesContext, expContext, expContext.ParentContext));
}
break;
}
throw new SyntaxException(string.Format("Cannot resolve symbol {0}", this.MemberValue), this.Member.Line, this.Member.Column);
}
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext)
{
return(this.GetExpressions(new Expression()
{
Classify = ExpressionType.Super
}));
}
private static PackagesLock ExtractLock(PackagesContext context)
{
return(new PackagesLock(context.Packages.ToImmutableDictionary(x => x,
x => (IImmutableList <PackageIdentity>)context.PackageDependencies[x].Dependencies
.Select(y => context.Packages.FirstOrDefault(z => z.Id == y.Id)).Where(y => y != null)
.ToImmutableList())));
}
private IEnumerable <ResolvedAction> GetRequiredActions(PackagesContext context)
{
var packagesToUninstall = new HashSet <PackageIdentity>(_project.InstalledPackages.Select(x => x.Key), PackageIdentity.Comparer);
var packagesToInstall = new HashSet <PackageIdentity>(PackageIdentity.Comparer);
foreach (var packageIdentity in context.Packages)
{
if (packagesToUninstall.Contains(packageIdentity))
{
packagesToUninstall.Remove(packageIdentity);
}
else
{
packagesToInstall.Add(packageIdentity);
}
}
var actions = new List <ResolvedAction>(packagesToUninstall.Select(ResolvedAction.CreateUninstall));
foreach (var packageIdentity in packagesToInstall)
{
actions.Add(ResolvedAction.CreateInstall(packageIdentity, context.PackageDependencies[packageIdentity].Source));
}
return(actions);
}
private GenericityType GetPrefixType(PackagesContext packagesContext, IContext context)
{
var prefixList = this.Objectexp.Symbol.GetExpressions(packagesContext, context);
if (prefixList.Length != 1)
{
throw new SyntaxException("Cannot call function here.", this.Lparen.Line, this.Lparen.Column);
}
var prefix = prefixList[0];
if (prefix.Type == Type.Any || prefix.Type == Type.Table)
{
return(GenericityType.Any);
}
if (!(prefix.Type.Name == Type.Function.Name && prefix.Type.PackageName == Type.Function.PackageName))
{
throw new SyntaxException("Cannot call function here.", this.Lparen.Line, this.Lparen.Column);
}
var tlGenericityType = prefix.Type as GenericityType;
if (tlGenericityType == null)
{
throw new SyntaxException("Cannot call function here.", this.Lparen.Line, this.Lparen.Column);
}
return(tlGenericityType);
}
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext)
{
return(this.GetExpressions(new Expression()
{
Classify = ExpressionType.This, Type = expContext.ClassContext.GetTLType()
}));
}
public override Type GetTLType(PackagesContext packagesContext)
{
if (packagesContext == null)
{
return(new Type(this.Identifier.Symbol, null, TypeCategory.Class));
}
return(packagesContext.GetTLType(this.Identifier.Symbol));
}
public Expression[] GetExpressions(PackagesContext packagesContext, IContext expContext)
{
if (this.Expressions == null)
{
this.Expressions = this.OnGetExpressions(packagesContext, expContext);
}
return(this.Expressions);
}
public Type[] GetReturnValues(PackagesContext packagesContext, IContext expContext)
{
if (this.returnValues != null)
{
return(this.returnValues);
}
this.returnValues = this.OnGetReturnValues(packagesContext, expContext);
return(this.returnValues);
}
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext)
{
var functionContext = this.Functionbody.Symbol.GetFunctionContext(expContext);
return(this.GetExpressions(new Expression()
{
Classify = ExpressionType.Value, Type = functionContext.Type, Element = functionContext
}));
}
public bool ExpTypeIs(Type type, PackagesContext packagesContext, IContext expContext)
{
var tlValues = this.GetExpressions(packagesContext, expContext);
if (tlValues.Length == 1)
{
return(tlValues[0].Type == type);
}
return(false);
}
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext)
{
var c = packagesContext.GetClass(this.Identifier.Symbol);
if (c == null)
{
throw new SyntaxException(string.Format("Cannot resolve symbol {0}", this.Identifier.Symbol), this.Identifier.Line, this.Identifier.Column);
}
return(this.GetExpressionsWithValue(packagesContext.GetTLType(this.Identifier.Symbol)));
}
public override bool BuildPackageContext(PackagesContext packages)
{
try
{
packages.Import(this.Packagename.Symbol.GetPackageName());
}
catch (Exception e)
{
throw new SyntaxException(e.Message, this.Import.Line, this.Import.Column);
}
return(true);
}
private void ClarifyType(Field field, PackagesContext packagesContext)
{
try
{
field.Type.ClarifyType(packagesContext);
}
catch (UnknowTypeException e)
{
var positionToken = field.DefineProduction.GetPositionToken();
throw new SyntaxException(e.Message, positionToken.Line, positionToken.Column);
}
}
public override Type[] GetTLType(PackagesContext packagesContext)
{
var tokens = this.Typelist.Symbol.GetTypes(new List <Token <Type_basisproduction> >());
Type[] types = new Type[tokens.Count];
for (int i = 0; i < tokens.Count; i++)
{
Token <Type_basisproduction> token = tokens[i];
types[i] = token.Symbol.GetTLType(packagesContext);
}
return(types);
}
public Expression[] GetExpTypeWithHashTable(
PackagesContext packagesContext,
IContext expContext,
GenericityType prefixType,
Expression indexValue)
{
if (indexValue.Type != prefixType.FirstGroupGenericTypeArguments[0] || indexValue.Classify != ExpressionType.Value)
{
throw new SyntaxException("Cannot resolve symbol here.", this.Lbracket.Line, this.Lbracket.Column);
}
return(this.GetExpressionsWithValue(prefixType.FirstGroupGenericTypeArguments[1]));
}
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext)
{
var tlType = this.Type.Symbol.GetTLType(packagesContext);
if (!tlType.IsDecidedType())
{
var type = packagesContext.GetTLType(tlType.Name);
tlType.PackageName = type.PackageName;
tlType.Name = type.Name;
}
return(this.GetExpressionsWithValue(tlType));
}
public virtual void ClarifyType(PackagesContext packagesContext)
{
if (!this.IsDecidedType())
{
var type = packagesContext.GetTLType(this.Name);
if (type == null)
{
throw new UnknowTypeException(string.Format("Cannot find type '{0}' in {1}", this.Name, packagesContext.Class.ClassFullName));
}
this.PackageName = type.PackageName;
this.Name = type.Name;
}
}
public override Parameter[] GetParameters(PackagesContext packagesContext)
{
var @params = this.Parameterlist.Symbol.GetParams(new List <Token <Parameter_basisproduction> >());
Parameter[] tlParameters = new Parameter[@params.Count];
for (int i = 0; i < @params.Count; i++)
{
Token <Parameter_basisproduction> token = @params[i];
tlParameters[i] = token.Symbol.GetParameter(packagesContext);
}
return(tlParameters);
}
public PackagesFileReader(IPackagesFilesLocator packagesFilesLocator,
PackagesContext context,
ISolutionFileLocator solutionFileLocator,
IOptions <PackagesFileConfig> packagesFileConfig,
IProjectFileLocator projectFileLocators,
IPackageFeedReader packageFeedReader)
{
_packagesFilesLocator = packagesFilesLocator;
_context = context;
_solutionFileLocator = solutionFileLocator;
_projectFileLocators = projectFileLocators;
_packageFeedReader = packageFeedReader;
_packagesFileConfig = packagesFileConfig.Value;
}
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext)
{
var returnValues = this.Functioncall.Symbol.GetReturnValues(packagesContext, expContext);
var tlValues = new Expression[returnValues.Length];
for (int i = 0; i < returnValues.Length; i++)
{
var returnValue = returnValues[i];
tlValues[i] = new Expression()
{
Classify = ExpressionType.Value, Type = returnValue
};
}
return(this.GetExpressions(tlValues));
}
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext)
{
var symbol = this.Identifier.Symbol;
var t = packagesContext.GetTLType(symbol);
if (t != null)
{
return(this.GetExpressionsWithClass(t));
}
var contextElement = expContext.GetElementInParent(symbol, expContext);
if (contextElement != null)
{
return(this.GetExpressionsWithValue(contextElement.Type));
}
throw new SyntaxException(string.Format("Cannot resolve symbol '{0}'", this.Identifier.Symbol), this.Identifier.Line, this.Identifier.Column);
}
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext)
{
var prefixList = this.Objectexp.Symbol.GetExpressions(packagesContext, expContext);
if (prefixList.Length != 1)
{
throw new SyntaxException("Cannot resolve symbol here.", this.Lbracket.Line, this.Lbracket.Column);
}
var prefix = prefixList[0];
if (prefix.Type == Type.Table || prefix.Type == Type.Any)
{
return(new[] { new Expression()
{
Classify = ExpressionType.Value, Type = Type.Any
} });
}
if (prefix.Classify != ExpressionType.Value)
{
throw new SyntaxException("Cannot resolve symbol here.", this.Lbracket.Line, this.Lbracket.Column);
}
if (!(prefix.Type is GenericityType))
{
throw new SyntaxException("Cannot resolve symbol here.", this.Lbracket.Line, this.Lbracket.Column);
}
var prefixType = prefix.Type as GenericityType;
var indexExpValue = this.Exp.Symbol.GetExpressions(packagesContext, expContext);
if (indexExpValue.Length != 1)
{
throw new SyntaxException("Cannot resolve symbol here.", this.Lbracket.Line, this.Lbracket.Column);
}
if (prefixType.Name == Type.ListTable.Name && prefixType.PackageName == Type.ListTable.PackageName)
{
return(this.GetExpTypeWithListTable(packagesContext, expContext, prefixType, indexExpValue[0]));
}
if (prefixType.Name == Type.HashTable.Name && prefixType.PackageName == Type.HashTable.PackageName)
{
return(this.GetExpTypeWithHashTable(packagesContext, expContext, prefixType, indexExpValue[0]));
}
throw new SyntaxException("Cannot resolve symbol here.", this.Lbracket.Line, this.Lbracket.Column);
}
public override bool BuildPackageContext(PackagesContext packages)
{
try
{
packages.Import(packages.Class.PackageName);
}
catch (Exception e)
{
throw new SyntaxException(e.Message, this.Packagedec.Line, this.Packagedec.Column);
}
var importDecs = this.Importlist.Symbol.GetImportDecs(new List <Token <Import_dec_basisproduction> >());
foreach (var importDec in importDecs)
{
importDec.Symbol.BuildPackageContext(packages);
}
return(true);
}
public override void ClarifyType(PackagesContext packagesContext)
{
if (!this.IsDecidedType())
{
if (this.FirstGroupGenericTypeArguments != null)
{
foreach (var genericTypeArgument in this.FirstGroupGenericTypeArguments)
{
genericTypeArgument.ClarifyType(packagesContext);
}
}
if (this.SecondGroupGenericTypeArguments != null)
{
foreach (var genericTypeArgument in this.SecondGroupGenericTypeArguments)
{
genericTypeArgument.ClarifyType(packagesContext);
}
}
}
base.ClarifyType(packagesContext);
}
private void ClarifyType(Function function, PackagesContext packagesContext)
{
if (function == null)
{
return;
}
if (function.Parameters != null)
{
foreach (var parameter in function.Parameters)
{
parameter.Type.ClarifyType(packagesContext);
}
}
if (function.ReturnValueTypes != null)
{
foreach (var returnValueType in function.ReturnValueTypes)
{
returnValueType.ClarifyType(packagesContext);
}
}
}
private Expression[] GetExpTypeAsClass(
PackagesContext packagesContext,
IContext expContext,
IContext targetContext)
{
var elementInParent = targetContext.GetElementInParent(this.MemberValue, expContext);
if (elementInParent.ElementCategory == ContextElementCategory.Field)
{
var field = elementInParent as Field;
if ((int)(field.Access & AccessType.Global) != 0)
{
throw new SyntaxException(string.Format("Cannot access global symbol '{0}'", this.MemberValue), this.Member.Line, this.Member.Column);
}
if ((int)(field.Access & AccessType.Static) == 0)
{
throw new SyntaxException(string.Format("Cannot access non-static symbol '{0}'", this.MemberValue), this.Member.Line, this.Member.Column);
}
return(this.GetExpressionsWithValue((elementInParent as Variable).Type));
}
throw new SyntaxException(string.Format("Cannot resolve symbol '{0}'", this.MemberValue), this.Member.Line, this.Member.Column);
}
private Expression[] GetExpTypeAsVariable(PackagesContext packagesContext, IContext expContext, IContext targetContext)
{
var elementInParent = targetContext.GetElementInParent(this.MemberValue, expContext);
if (elementInParent == null)
{
throw new SyntaxException(string.Format("Cannot access symbol '{0}' here.", this.MemberValue), this.Member.Line, this.Member.Column);
}
if (elementInParent.ElementCategory == ContextElementCategory.Variable || elementInParent.ElementCategory == ContextElementCategory.Parameter)
{
return(this.GetExpressionsWithValue(elementInParent.Type));
}
if (elementInParent.ElementCategory == ContextElementCategory.Function)
{
var function = elementInParent as Function;
if (function.ParentContext is Class)
{
if ((int)(function.Access & AccessType.Global) != 0)
{
throw new SyntaxException(string.Format("Cannot access global symbol '{0}'", this.MemberValue), this.Member.Line, this.Member.Column);
}
}
this.accessType = ":";
this.accessType = ".";
return(this.GetExpressionsWithValue(elementInParent.Type));
}
if (elementInParent.ElementCategory == ContextElementCategory.Field)
{
var field = elementInParent as Field;
if ((int)(field.Access & AccessType.Global) != 0)
{
throw new SyntaxException(string.Format("Cannot access global symbol '{0}'", this.MemberValue), this.Member.Line, this.Member.Column);
}
return(this.GetExpressionsWithValue(elementInParent.Type));
}
throw new SyntaxException(string.Format("Cannot resolve symbol '{0}'", this.MemberValue), this.Member.Line, this.Member.Column);
}
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext)
{
return(this.GetExpressionsWithValue(Type.Number));
}
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext)
{
this.Equalityexp.Symbol.GetExpressions(packagesContext, expContext);
this.Compareexp.Symbol.GetExpressions(packagesContext, expContext);
return(this.GetExpressionsWithValue(Type.Bool));
}
