Changeset 13095 for branches/dev-mj-1626


Ignore:
Timestamp:
Jul 9, 2019 3:08:30 PM (5 months ago)
Author:
tgutzmann
Message:

Merge from trunk

Location:
branches/dev-mj-1626
Files:
1 deleted
24 edited
5 copied

Legend:

Unmodified
Added
Removed
  • branches/dev-mj-1626

  • branches/dev-mj-1626/CHANGELOG.txt

    r12995 r13095  
    11================= Unreleased ==================
     2# Change ; Major; PyFMI ; #5802
     3Updated JModelica external to PyFMI 2.5.3
     4
     5# Change ; Minor ; Compiler ; #5800
     6SrcDot now has SrcNamedAccess instead of SrcAccess as children.
     7
    28# Fixed ; Minor ; Compiler ; #5791
    39Fixed source-tree lookup for modifications: don't look up in normal scope if not found in member scope.
  • branches/dev-mj-1626/Compiler/ModelicaCompiler/src/jastadd/ModelicaCompiler.jrag

    r12978 r13095  
    22292229syn File SrcAccess.findOutermostLibraryDirForWithin(File f) = null;
    22302230eq SrcDot.findOutermostLibraryDirForWithin(File f) {
    2231     for (int i = getNumSrcAccess() - 1; i >= 0 && f != null; i--)
    2232         f = getSrcAccess(i).findOutermostLibraryDirForWithin(f);
     2231    for (int i = getNumSrcNamedAccess() - 1; i >= 0 && f != null; i--)
     2232        f = getSrcNamedAccess(i).findOutermostLibraryDirForWithin(f);
    22332233    return f;
    22342234}
  • branches/dev-mj-1626/Compiler/ModelicaFlatTree/src/jastadd/Arrays.jrag

    r12940 r13095  
    2323import java.util.Iterator;
    2424import java.util.NoSuchElementException;
     25
     26import org.jmodelica.util.collections.ListUtil;
     27import org.jmodelica.util.collections.IntIterator;
    2528
    2629aspect Arrays {
     
    383386    }
    384387    eq InstGlobalAccess.ndims() = getInstAccess().ndims();
    385    
    386     /**
    387      * Get the expanded FArraySubscripts of each part of this access.
    388      */
    389     eq InstAccess.allFArraySubscripts() = Arrays.<FArraySubscripts>asList(new FArrayLitSubscripts());
    390     eq InstArrayAccess.allFArraySubscripts() = Arrays.asList(getFArraySubscripts());
    391     eq InstScalarAccess.allFArraySubscripts() = Arrays.asList(getExpandedSubscripts());
    392     eq InstDot.allFArraySubscripts() {
    393         int n = getNumInstAccess();
    394         java.util.List<FArraySubscripts>[] lists = new java.util.List[n];
    395         for (int i = 0; i < n; i++)
    396             lists[i] = getInstAccess(i).allFArraySubscripts();
    397         return concatenation(lists);
    398     }
    399     eq InstGlobalAccess.allFArraySubscripts() = getInstAccess().allFArraySubscripts();
    400    
    401     /**
    402      * Get the expanded FArraySubscripts of each part of the fully qualified version of this access.
    403      */
    404     syn java.util.List<FArraySubscripts> InstAccess.qualifiedAllFArraySubscripts() =
    405         concatenation(surroundingFArraySubscripts(), allFArraySubscripts());
    406     eq InstGlobalAccess.qualifiedAllFArraySubscripts() = allFArraySubscripts();
    407    
    408     /**
    409      * Get the expanded FArraySubscripts for any surrounding components.
    410      */
    411     inh ArrayList<FArraySubscripts> InstAccess.surroundingFArraySubscripts();
    412     inh lazy ArrayList<FArraySubscripts> InstArrayComponentDecl.surroundingFArraySubscripts();
    413     eq Root.getChild().surroundingFArraySubscripts()          = new ArrayList<FArraySubscripts>(0);
    414     eq InstClassDecl.getChild().surroundingFArraySubscripts() = new ArrayList<FArraySubscripts>(0);
    415     eq InstArrayComponentDecl.getChild().surroundingFArraySubscripts() {
    416         FArraySubscripts fas;
    417         ArrayList<FArraySubscripts> res;
    418         if (isTopDimension()) {
    419             fas = new FArrayLitSubscripts();
    420             res = concatenation(surroundingFArraySubscripts(), Collections.singletonList(fas));
    421         } else {
    422             res = (ArrayList<FArraySubscripts>) surroundingFArraySubscripts().clone();
    423             int i = res.size() - 1;
    424             fas = res.get(i).fullCopy();
    425             res.set(i, fas);
    426         }
    427         fas.addFSubscript(getIndex());
    428         return res;
    429     }
    430    
    431     public class ASTNode {
    432         public static <T> ArrayList<T> concatenation(java.util.List<T>... lists) {
    433             int size = 0;
    434             for (java.util.List<T> list : lists)
    435                 size += list.size();
    436             ArrayList<T> res = new ArrayList<T>(size);
    437             for (java.util.List<T> list : lists)
    438                 res.addAll(list);
    439             return res;
    440         }
    441     }
    442    
     388
     389    /**
     390     * Get array dimensions up to this part for a part of a dotted access. For
     391     * an access that is not part of a dotted access, this is equivalent to ndims().
     392     *
     393     * A value > 0 indicates an array, 0 indicates a scalar and -1 indicates
     394     * an error in computation of the array dimensions.
     395     */
     396    syn int InstAccess.combinedNdims() = collectCombinedNdims() + ndims();
     397
     398    inh int InstAccess.collectCombinedNdims();
     399    eq BaseNode.getChild()          .collectCombinedNdims() = 0;
     400    eq InstDot .getInstAccess(int i).collectCombinedNdims() {
     401        int n = 0;
     402        for (int j = 0; j < i; j++) {
     403            n += getInstAccess(j).ndims();
     404        }
     405        return n;
     406    }
     407
     408    /**
     409     * Get the expanded FArraySubscripts of each part of this access.
     410     */
     411    eq InstAccess      .allFArraySubscripts() = Arrays.<FArraySubscripts>asList(new FArrayLitSubscripts());
     412    eq InstArrayAccess .allFArraySubscripts() = Arrays.asList(getFArraySubscripts());
     413    eq InstScalarAccess.allFArraySubscripts() = Arrays.asList(getExpandedSubscripts());
     414    eq InstDot         .allFArraySubscripts() = allFArraySubscriptsTo(getNumInstAccess());
     415    eq InstGlobalAccess.allFArraySubscripts() = getInstAccess().allFArraySubscripts();
     416
     417    /**
     418     * Get the expanded FArraySubscripts of each part up to this for a part of a dotted access.
     419     * For an access that is not part of a dotted access, this is equivalent to
     420     * {@link InstAccess#qualifiedAllFArraySubscripts()}.
     421     */
     422    syn java.util.List<FArraySubscripts> InstAccess.combinedFArraySubscripts() =
     423        ListUtil.concatenate(collectCombinedFArraySubscripts(),
     424                             allFArraySubscripts());
     425
     426    inh java.util.List<FArraySubscripts> InstAccess.collectCombinedFArraySubscripts();
     427    eq BaseNode.getChild()          .collectCombinedFArraySubscripts() = Collections.emptyList();
     428    eq InstDot .getInstAccess(int i).collectCombinedFArraySubscripts() = allFArraySubscriptsTo(i);
     429
     430    private java.util.List<FArraySubscripts> InstDot.allFArraySubscriptsTo(int n) {
     431        java.util.List<FArraySubscripts>[] lists = new java.util.List[n];
     432        for (int i = 0; i < n; i++) {
     433            lists[i] = getInstAccess(i).allFArraySubscripts();
     434        }
     435        return ListUtil.concatenate(lists);
     436    }
     437
    443438    /**
    444439     * Get the expanded FArraySubscripts of each part of this access.
     
    11201115     * Get the array sizes.
    11211116     */
    1122     eq InstAccess.size() = isArray() ? arraySize() : Size.SCALAR;
    1123    
    1124     syn Size InstAccess.arraySize() = Size.SCALAR;
    1125     eq InstGlobalAccess.arraySize() = getInstAccess().arraySize();
    1126     eq InstScalarAccess.arraySize() = getExpandedSubscripts().accessSize();
    1127     eq InstArrayAccess.arraySize()  = getFArraySubscripts().accessSize();
    1128     eq InstDot.arraySize() {
    1129         MutableSize s = new MutableSize(ndims());
    1130         for (InstAccess ia : getInstAccesss()) {
    1131             s.append(ia.size());
    1132         }
    1133         return s;
    1134     }
    1135    
     1117    eq InstAccess.size() = Size.SCALAR;
     1118    eq InstGlobalAccess.size() = getInstAccess().size();
     1119    eq InstScalarAccess.size() = getExpandedSubscripts().accessSize();
     1120    eq InstArrayAccess.size()  = getFArraySubscripts().accessSize();
     1121    eq InstDot.size() {
     1122        if (isArray()) {
     1123            MutableSize s = new MutableSize(ndims());
     1124            for (InstAccess ia : getInstAccesss()) {
     1125                s.append(ia.size());
     1126            }
     1127            return s;
     1128        } else {
     1129            return Size.SCALAR;
     1130        }
     1131    }
     1132
     1133    /**
     1134     * Get the size of all parts of an InstDot up to this part.
     1135     */
     1136    inh Size InstAccess.partSize();
     1137    eq BaseNode.getChild().partSize() = null;
     1138    eq InstDot.getInstAccess(int i).partSize() {
     1139        int ndims = 0;
     1140        for (int j = 0; j <= i; j++) {
     1141            ndims += getInstAccess(j).ndims();
     1142        }
     1143        if (ndims == 0) {
     1144            return Size.SCALAR;
     1145        } else {
     1146            MutableSize s = new MutableSize(ndims);
     1147            for (int j = 0; j <= i; j++) {
     1148                s.append(getInstAccess(j).size());
     1149            }
     1150            return s;
     1151        }
     1152    }
     1153
    11361154    /**
    11371155     * Get the array sizes.
     
    21532171        }
    21542172    }
    2155    
     2173
     2174    /**
     2175     * Get a specific cell of this array component decl.
     2176     *
     2177     * Only valid if this is an array and <code>i</code> refers to an element of it.
     2178     */
     2179    syn InstComponentDecl InstComponentDecl.specify(Index i) = specifyHelper(i, 0);
     2180
     2181    syn InstComponentDecl InstComponentDecl.specifyHelper(Index i, int d) =
     2182        (d >= i.ndims() || !isArray())
     2183            ? this
     2184            : getInstComponentDecl(i.get(d) - 1).specifyHelper(i, d + 1);
     2185    eq InstPrimitive.specifyHelper(Index i, int d) = this;
     2186
    21562187    syn InstArrayAccess InstScalarAccess.getArrayCopy(FArraySubscripts fas);
    21572188    eq InstParseAccess.getArrayCopy(FArraySubscripts fas) = new InstParseArrayAccess(getID(), fas);
     
    22812312     * @return An Indices object containing all indices in each array dimension.
    22822313     */
    2283     syn Indices InstAccess.indices() = Indices.createFromFas(qualifiedAllFArraySubscripts());
     2314    syn Indices InstAccess.indices() = Indices.createFromFas(allFArraySubscripts());
     2315
     2316    /**
     2317     * Get the set of array indices up to this part for a part of a dotted access. For
     2318     * an access that is not part of a dotted access, this is equivalent to indices().
     2319     */
     2320    syn Indices InstAccess.combinedIndices() = Indices.createFromFas(combinedFArraySubscripts());
    22842321
    22852322    /**
     
    38993936     *        multi-dimensional) array.
    39003937     *       
    3901      * Index objects are reused to a high degree. Always use clone() when retaining
     3938     * Index objects are reused to a high degree. Always use fix() when retaining
    39023939     * an Index object.
    39033940     */
    3904     public class Index implements Cloneable {
     3941    public class Index {
    39053942       
    39063943        public static final Index NULL = new Index(0);
     
    39423979            return index.length > 0 ? index[index.length - 1] : -1;
    39433980        }
    3944        
     3981       
     3982        /**
     3983         * Returns an iterator over the indices for each dimension.
     3984         */
     3985        public IntIterator iterator() {
     3986            return new IntIterator() {
     3987                int d = 0;
     3988               
     3989                public boolean hasNext() { return d < index.length; }
     3990               
     3991                public int next() { return index[d++]; }
     3992            };
     3993        }
     3994       
    39453995        /**
    39463996         * Returns the index for the <code>i</code>th dimension (zero-based).
     
    39984048                return this;
    39994049            if (i == j)
    4000                 return NULL;
     4050                return Index.NULL;
    40014051            Index copy = new Index(j - i);
    40024052            System.arraycopy(index, i, copy.index, 0, copy.index.length);
     
    40354085            return new FArrayLitSubscripts(index);
    40364086        }
    4037        
    4038         /**
    4039          * Copies this Index. Always use clone() when saving an Index.
    4040          */
    4041         public Index clone() {
    4042             try {
    4043                 Index i = (Index) super.clone();
    4044                 i.index = index.clone();
    4045                 return i;
    4046             } catch (CloneNotSupportedException e) {
    4047                 return null;
    4048             }
    4049         }
    4050        
     4087
     4088        /**
     4089         * Returns an Index that has the same value as this one, but will not be changed by
     4090         * an iterator that might have returned this Index. Usually creates a copy.
     4091         * Always use fix() when saving an Index.
     4092         */
     4093        public Index fix() {
     4094            if (index.length == 0) {
     4095                return Index.NULL;
     4096            } else {
     4097                return new Index(index.clone());
     4098            }
     4099        }
     4100
    40514101        /**
    40524102         * Returns an Index that is the result of appending <code>i</code> to this Index.
     
    42364286            return size;
    42374287        }
    4238        
    4239         /**
    4240          * Translates an Index to the corresponding Index in the underlying
    4241          *        expression.
    4242          *
    4243          * Default implementation always returns <code>i</code>.
    4244          */
    4245         public Index translate(Index i) {
    4246             return i;
    4247         }
    4248        
     4288
     4289        /**
     4290         * Translates an Index to the corresponding Index in the underlying expression.
     4291         * If i has fewer dimensions than this, than it should correspond to the outermost ones.
     4292         *
     4293         * Note that for some implementations, the returned index may be changed by subsequent
     4294         * calls to this method.
     4295         *
     4296         * Default implementation always returns <code>i</code>.
     4297         */
     4298        public Index translate(Index i) {
     4299            return i;
     4300        }
     4301
     4302        public Indices translated() {
     4303            return this;
     4304        }
     4305
    42494306        /**
    42504307         * Add values to an index map for a given index from this set and a given set of for indices.
     
    42954352        }
    42964353       
    4297         /**
    4298          * Iterates over all indices spanned by this Indices.
    4299          */
    4300         protected class IIterator implements Iterator<Index> {
    4301            
    4302             protected IIndex index;
    4303             protected int max;
    4304            
    4305             public IIterator() {
    4306                 index = new IIndex();
    4307                 max = numElements() - 1;
    4308             }
    4309            
    4310             public boolean hasNext() {
    4311                 return index.internal < max;
    4312             }
    4313            
    4314             public Index next() {
    4315                 if (index.internal >= max)
    4316                     throw new NoSuchElementException();
    4317                 index.internal++;
    4318                 if (ndims == 0)
    4319                     return index;
    4320                 int[] ind = index.index();
    4321                 int i;
    4322                 for (i = ndims - 1; i > 0 && ind[i] >= size.get(i); i--)
    4323                     ind[i] = 1;
    4324                 ind[i]++;
    4325                 return index;
    4326             }
    4327            
    4328             public void remove() {
    4329                 throw new UnsupportedOperationException();
    4330             }
    4331            
    4332         }
     4354        /**
     4355         * Iterates over all indices spanned by this Indices.
     4356         */
     4357        protected class IIterator implements Iterator<Index> {
     4358           
     4359            protected IIndex index;
     4360            protected int max;
     4361           
     4362            public IIterator() {
     4363                index = new IIndex();
     4364                max = numElements() - 1;
     4365            }
     4366           
     4367            public boolean hasNext() {
     4368                return index.internal < max;
     4369            }
     4370           
     4371            public Index next() {
     4372                if (index.internal >= max)
     4373                    throw new NoSuchElementException();
     4374                index.internal++;
     4375                if (ndims == 0) {
     4376                    return Index.NULL;
     4377                }
     4378                int[] ind = index.index();
     4379                int i;
     4380                for (i = ndims - 1; i > 0 && ind[i] >= size.get(i); i--)
     4381                    ind[i] = 1;
     4382                ind[i]++;
     4383                return index;
     4384            }
     4385           
     4386            public void remove() {
     4387                throw new UnsupportedOperationException();
     4388            }
     4389           
     4390        }
    43334391       
    43344392        /**
     
    44564514        }
    44574515
    4458         /**
    4459          * Translates an Index to the corresponding Index in the underlying
    4460          * expression.
    4461          */
    4462         public Index translate(Index i) {
    4463             int[] ii = i.index();
    4464             int[] ti = trans.index();
    4465             for (int ji = 0, jt = 0; ji < ndims && jt < ti.length; ji++, jt++) {
    4466                 while (trim[jt])
    4467                     jt++;
    4468                 ti[jt] = indices.get(jt)[ii[ji] - 1];
    4469             }
    4470             return trans;
    4471         }
    4472 
    4473        
    4474         /**
    4475          * Internal constructor to create a NonConsecutiveIndices object based on a
    4476          * list of int arrays containing the used indexes on the underlying array.
    4477          *
    4478          * @param trim   the dimensions to remove
    4479          * @param extra  number of extra dimensions of length 1 to add
    4480          */
    4481         protected NonConsecutiveIndices(ArrayList<int[]> ind, boolean[] trim, int extra) {
    4482             super(getSize(ind, trim, extra));
    4483             this.trim = trim;
    4484             indices = ind;
    4485             trans = new Index(ind.size());
    4486             for (int i = 0; i < ind.size(); i++)
    4487                 if (indices.get(i).length > 0)
    4488                     trans.index()[i] = indices.get(i)[0];
    4489         }
    4490        
     4516        /**
     4517         * Internal constructor to create a NonConsecutiveIndices object based on a
     4518         * list of int arrays containing the used indexes on the underlying array.
     4519         *
     4520         * @param trim   the dimensions to remove
     4521         * @param extra  number of extra dimensions of length 1 to add
     4522         */
     4523        protected NonConsecutiveIndices(ArrayList<int[]> ind, boolean[] trim, int extra) {
     4524            super(getSize(ind, trim, extra));
     4525            this.trim = trim;
     4526            indices = ind;
     4527            trans = intializeTranslated(ind.size());
     4528        }
     4529
     4530        /**
     4531         * Translates an Index to the corresponding Index in the underlying expression.
     4532         * If i has fewer dimensions than this, than it should correspond to the outermost ones.
     4533         *
     4534         * Note that the returned Index may be changed by subsequent calls to this method,
     4535         * use {@link Index.fix()} if you need to save it.
     4536         */
     4537        @Override
     4538        public Index translate(Index i) {
     4539            int[] ii = i.index();
     4540            int transNDims = ii.length + trim.length - ndims;
     4541            if (trans.ndims() != transNDims) {
     4542                trans = intializeTranslated(transNDims);
     4543            }
     4544            int[] ti = trans.index();
     4545            for (int ji = 0, jt = 0; ji < ndims && jt < ti.length; ji++, jt++) {
     4546                while (trim[jt]) {
     4547                    jt++;
     4548                }
     4549                ti[jt] = indices.get(jt)[ii[ji] - 1];
     4550            }
     4551            return trans;
     4552        }
     4553
     4554        /**
     4555         * Prepare a new Index for returning from the translate method.
     4556         */
     4557        protected Index intializeTranslated(int n) {
     4558            Index trans = new Index(n);
     4559            for (int i = 0; i < n; i++) {
     4560                if (indices.get(i).length > 0) {
     4561                    trans.index()[i] = indices.get(i)[0];
     4562                }
     4563            }
     4564            return trans;
     4565        }
     4566
     4567        @Override
     4568        public Indices translated() {
     4569            return new TranslatedIndices(this);
     4570        }
     4571
     4572        private static class TranslatedIndices extends Indices {
     4573           
     4574            private NonConsecutiveIndices indices;
     4575           
     4576            private TranslatedIndices(NonConsecutiveIndices indices) {
     4577                super(indices.size);
     4578                this.indices = indices;
     4579            }
     4580           
     4581            @Override
     4582            public Iterator<Index> iterator() {
     4583                return new Iter();
     4584            }
     4585           
     4586            private class Iter implements Iterator<Index> {
     4587               
     4588                private Iterator<Index> iterator;
     4589               
     4590                private Iter() {
     4591                    iterator = indices.iterator();
     4592                }
     4593               
     4594                public boolean hasNext() {
     4595                    return iterator.hasNext();
     4596                }
     4597                public Index next() {
     4598                    return indices.translate(iterator.next());
     4599                }
     4600                public void remove() {
     4601                    iterator.remove();
     4602                }
     4603            }
     4604        }
     4605
    44914606        /**
    44924607         * Calculate size for this indices from a list of int arrays containing the
     
    44984613                if (!tr)
    44994614                    n++;
    4500             if (n == 0) {
     4615            if (n + extra == 0) {
    45014616                return Size.SCALAR;
    45024617            }
  • branches/dev-mj-1626/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

    r13009 r13095  
    40744074 
    40754075
    4076     public class EvaluataionValueCache {
     4076    public class EvaluationValueCache {
    40774077
    40784078        private Map<CommonVariableDecl,CValue> values;
    40794079        private Map<CommonVariableDecl,CValue> old;
    40804080
    4081         public EvaluataionValueCache(ASTNode source) {
     4081        public EvaluationValueCache(ASTNode source) {
    40824082            values = source.collectEvaluationValues(null);
    40834083        }
  • branches/dev-mj-1626/Compiler/ModelicaFlatTree/src/jastadd/PrettyPrint.jrag

    r13009 r13095  
    938938
    939939    public void SrcDot.prettyPrint(Printer p, CodeStream str, String indent) {
    940         getSrcAccesss().prettyPrintWithSep(p, str, indent, ".");
     940        getSrcNamedAccesss().prettyPrintWithSep(p, str, indent, ".");
    941941    }
    942942
  • branches/dev-mj-1626/Compiler/ModelicaFlatTree/src/jastadd/TypeAnalysis.jrag

    r12811 r13095  
    7575            for (Map.Entry<Index, T> entry : cells.entrySet()) {
    7676                for (Index index : Indices.create(size)) {
    77                     expandedCells.put(index.expand(entry.getKey()).clone(), entry.getValue());
     77                    expandedCells.put(index.expand(entry.getKey()).fix(), entry.getValue());
    7878                }
    7979            }
     
    773773                t = t.expand(size().contractRight(ndimsWithoutFAS - ip.ndims()));
    774774                try {
    775                     t = t.cell(index()).asFType();
     775                    t = t.cell(accessIndex()).asFType();
    776776                } catch (ConstantEvaluationException e) {
    777777                    t = ndims() > 0 ? t.arrayType(size()) : t.scalarType();
  • branches/dev-mj-1626/Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo

    r12934 r13095  
    17661766    Real[:,:] y = f({{time,time}}, {{{time},{time}}});
    17671767    Real[1,2] y1 = f({{1,2}}, {{{3},{4}}});
    1768    
     1768
    17691769    annotation(__JModelica(UnitTesting(tests={
    17701770        EvalTestCase(
    1771             name="VectorFuncEval4",
     1771            name="VectorFuncEval5",
    17721772            description="Constant evaluation of vectorized function call",
    17731773            variables="
  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/jastadd/ast/Modelica.ast

    r12761 r13095  
    323323
    324324abstract SrcAccess : SrcBaseNode;
    325 SrcDot             : SrcAccess      ::= SrcAccess*;
     325SrcDot             : SrcAccess      ::= SrcNamedAccess*;
    326326SrcGlobalAccess    : SrcAccess      ::= SrcAccess;
    327327SrcNamedAccess     : SrcAccess      ::= <ID>;
  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/jastadd/errorcheck/TypeCheck.jrag

    r12962 r13095  
    445445            new ErrorProducerUnlessDisabled("ARRAY_SIZE_MISMATCH_IN_CONNECT", ProblemKind.SEMANTIC,
    446446                    "Sizes do not match in connection, size of '%s' is %s and size of '%s' is %s");
     447    public static final ErrorProducerUnlessDisabled ASTNode.EXPANDABLE_ARRAY_SIZE_MISMATCH_IN_CONNECT =
     448            new ErrorProducerUnlessDisabled("ARRAY_SIZE_MISMATCH_IN_CONNECT", ProblemKind.SEMANTIC,
     449                    "Sizes do not match in connection, size of the part of '%s' referring to " +
     450                    "the expandable connector is %s and size of '%s' is %s");
    447451
    448452    public void FConnectClause.typeCheck(ErrorCheckType checkType) {
     
    450454        InstAccess right = getConnector2();
    451455        boolean checkTypes = !isDisabled();
     456        boolean isExpandable = false;
    452457        boolean expandableSame = true;
    453458        for (InstAccess access = left; access != null; access = (access == left) ? right : null) {
    454             if (!access.isExpandableConnectorPart() && !access.isUnknown() && !access.myInstComponentDecl().myInstClass().isUnknown()) {
     459            if (access.isExpandableConnectorPart()) {
     460                isExpandable = true;
     461            } else if (!access.isUnknown() && !access.myInstComponentDecl().myInstClass().isUnknown()) {
    455462                if (!access.myInstComponentDecl().isConnector())
    456463                    CONNECT_WITH_INVALID_TYPE.invoke(access);
     
    458465                checkTypes = false;
    459466            }
    460             if (access.myInstComponentDecl().isExpandableConnector())
     467            if (access.myInstComponentDecl().isExpandableConnector()) {
    461468                expandableSame = !expandableSame;
    462         }
    463         if (!expandableSame && !left.isUnknown() && !right.isUnknown())
     469            }
     470        }
     471        if (!expandableSame && !left.isUnknown() && !right.isUnknown()) {
    464472            CONNECT_EXPANDABLE_AND_NON_EXPANDABLE_TYPE.invoke(this);
     473        }
    465474        if (checkTypes) {
    466             InstComponentDecl leftComp  = left.lookupEvaluatingIndices();
    467             InstComponentDecl rightComp = right.lookupEvaluatingIndices();
    468             if (!leftComp.connectableTo(rightComp)) {
    469                 TYPE_MISMATCH_IN_CONNECT.invoke(this);
    470             } else if (!left.size().equivalent(right.size(), false)) {
    471                 ARRAY_SIZE_MISMATCH_IN_CONNECT.invokeWithCondition(this, left.ndims() == right.ndims(),
    472                         left, left.size(), right, right.size());
     475            if (isExpandable) {
     476                boolean leftUnknown = left.isExpandableConnectorPart();
     477                InstAccess known   = leftUnknown ? right : left;
     478                InstAccess unknown = leftUnknown ? left  : right;
     479                Size knownSize   = known.size();
     480                Size unknownSize = unknown.findExpandableConnectorPart().partSize();
     481                if (knownSize.ndims() < unknownSize.ndims() ||
     482                        !unknownSize.equivalent(knownSize.contractRight(unknownSize.ndims()), false)) {
     483                    EXPANDABLE_ARRAY_SIZE_MISMATCH_IN_CONNECT.invoke(
     484                            this, unknown, unknownSize, known, knownSize);
     485                }
     486            } else {
     487                InstComponentDecl leftComp  = left.lookupEvaluatingIndices();
     488                InstComponentDecl rightComp = right.lookupEvaluatingIndices();
     489                if (!leftComp.connectableTo(rightComp)) {
     490                    TYPE_MISMATCH_IN_CONNECT.invoke(this);
     491                } else if (!left.size().equivalent(right.size(), false)) {
     492                    ARRAY_SIZE_MISMATCH_IN_CONNECT.invokeWithCondition(this, left.ndims() == right.ndims(),
     493                            left, left.size(), right, right.size());
     494                }
    473495            }
    474496        }
  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstLookupComponents.jrag

    r12934 r13095  
    1515*/
    1616
     17import org.jmodelica.util.collections.IntIterator;
    1718
    1819aspect InstLookupComponents {
     
    494495
    495496    /**
    496      * Lookup component, re-evaluating any array accesses except in last component.
     497     * Lookup component, selecting array indices based on i, where i covers this access.
     498     */
     499    syn InstComponentDecl InstAccess.lookupWithIndex(Index i) = lookupWithIndexImpl(i, null);
     500
     501    /**
     502     * Lookup component, selecting array indices based on i, where i covers an InstDot that
     503     * this access is part of.
     504     */
     505    inh InstComponentDecl InstAccess.lookupAsPartWithIndex(Index i);
     506    eq InstDot .getInstAccess(int j).lookupAsPartWithIndex(Index i) =
     507        lookupWithIndexImpl(i, (j < getNumInstAccess() - 1) ? getInstAccess(j + 1) : null);
     508    eq BaseNode.getChild()          .lookupAsPartWithIndex(Index i) =
     509        unknownInstComponentDecl();
     510
     511    protected InstComponentDecl InstAccess.lookupWithIndexImpl(Index i, InstAccess stopAt) {
     512        InstAccess first = getFirstInstAccess();
     513        InstAccess cur = first;
     514        InstComponentDecl icd = cur.myInstComponentDecl();
     515        IntIterator index = i.iterator();
     516       
     517        while (cur != stopAt && icd != null && !icd.isUnknown()) {
     518            if (cur == first) {
     519                icd = icd.arrayCell(index);
     520            } else {
     521                icd = icd.memberArrayCell(cur.name(), index);
     522            }
     523            cur = cur.getNextInstAccess();
     524        }
     525       
     526        return (icd == null) ? unknownInstComponentDecl() : icd;
     527    }
     528
     529    syn InstComponentDecl InstComponentDecl.memberArrayCell(String name, IntIterator index) {
     530        InstComponentDecl res = memberInstComponent(name).targetOrNull();
     531        if (res != null) {
     532            res = res.arrayCell(index);
     533        }
     534        return res;
     535    }
     536
     537    syn InstComponentDecl InstComponentDecl.arrayCell(Index index) = arrayCell(index.iterator());
     538
     539    syn InstComponentDecl InstComponentDecl.arrayCell(IntIterator index) {
     540        if (index.hasNext() && isArray() && !isPrimitive()) {
     541            return getInstComponentDecl(index.next() - 1).arrayCell(index);
     542        } else {
     543            return this;
     544        }
     545    }
     546
     547    /**
     548     * Lookup component, re-evaluating any array indexes except in last component.
    497549     */
    498550    public InstComponentDecl InstAccess.lookupEvaluatingIndices() {
     
    604656    eq InstLibNode.arrayMemberInstComponent(String name, int ndims)              = actualInstClass().arrayMemberInstComponent(name, ndims);
    605657
    606     syn lazy InstLookupResult<InstComponentDecl> InstNode.memberInstComponent(String name)  {
     658    syn InstLookupResult<InstComponentDecl> InstNode.memberInstComponent(String name) {
    607659        if (isArray()) {
    608660            return arrayMemberInstComponent(name, ndims());
    609661        } else {   
    610             for (InstComponentDecl ic : getInstComponentDecls())
    611                 if (ic.matches(name))
    612                     return findInnerComponentIfAny(ic.duplicateOriginal());
    613 
    614             for (InstExtends ie : getInstExtendss()) {
    615                 InstLookupResult<InstComponentDecl> res = ie.memberInstComponent(name);
    616                 if (res.successful())
    617                     return res;
    618             }
    619            
    620             return InstLookupResult.notFound();
    621         }
     662            return memberInstComponentCached(name);
     663        }
     664    }
     665   
     666    syn lazy InstLookupResult<InstComponentDecl> InstNode.memberInstComponentCached(String name)  {
     667        for (InstComponentDecl ic : getInstComponentDecls()) {
     668            if (ic.matches(name)) {
     669                return findInnerComponentIfAny(ic.duplicateOriginal());
     670            }
     671        }
     672
     673        for (InstExtends ie : getInstExtendss()) {
     674            InstLookupResult<InstComponentDecl> res = ie.memberInstComponent(name);
     675            if (res.successful()) {
     676                return res;
     677            }
     678        }
     679       
     680        return InstLookupResult.notFound();
    622681    }
    623682    eq InstSimpleShortClassDecl.memberInstComponent(String name) = actualInstClass().memberInstComponent(name);
  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstTypeAnalysis.jrag

    r12595 r13095  
    243243                }
    244244            }
    245             decls.put(index.clone(), decl);
     245            decls.put(index.fix(), decl);
    246246        }
    247247        return new ArrayType(indices(), decls, type().scalarType());
     
    272272            Map<Index, FExp> exps = new HashMap<>();
    273273            for (Index i : bexp.indices()) {
    274                 exps.put(i.clone(), array.get(i));
     274                exps.put(i.fix(), array.get(i));
    275275            }
    276276            return new ArrayType(bexp.indices(), exps, bexp.type().scalarType());
  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstanceTree.jrag

    r12962 r13095  
    668668    eq InstComponentDecl.getInstConstrainingComponent().myEnvironment(String name) = getMergedEnvironment().clone();
    669669    eq InstBaseClassDecl.getInstConstrainingClass().myEnvironment(String name)     = getMergedEnvironment().clone();
     670    // TODO: This seems like the wriong name - shouldn't we filter on template's name?
    670671    eq InstExpandableConnectorDecl.getInstComponentDecl(int i).myEnvironment(String name)          =
    671672        useTemplate(i) ? template(i).myEnvironment(name) : myEnvironment_def(name);
     
    16681669    public InstAccess SrcDot.newInstAccess() {
    16691670        List<InstAccess> l = new List<InstAccess>();
    1670         for (SrcAccess a : getSrcAccesss())
     1671        for (SrcNamedAccess a : getSrcNamedAccesss())
    16711672            l.add(a.newInstAccess());
    16721673        InstDot ia = new InstDot(l);
  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/jastadd/source/SimpleLookup.jrag

    r12995 r13095  
    299299    */
    300300    inh ResolvedAccess ASTNode.simpleLookupHelper(String name);
    301     eq SrcDot.getSrcAccess(int i).simpleLookupHelper(String name)             = simpleLookupDot(name, i);
     301    eq SrcDot.getSrcNamedAccess(int i).simpleLookupHelper(String name)        = simpleLookupDot(name, i);
    302302    eq SrcGlobalAccess.getSrcAccess().simpleLookupHelper(String name)         = simpleLookupGlobalScope(name);
    303303    eq SrcArrayAccess.getSrcArraySubscripts().simpleLookupHelper(String name) = simpleLookupBypassDot(name);
     
    501501            return simpleLookupHelper(name);
    502502        }
    503         ResolvedAccess access = getSrcAccess(i - 1).resolveAccess();
     503        ResolvedAccess access = getSrcNamedAccess(i - 1).resolveAccess();
    504504        return access.simpleLookupMemberScope(name).fromContext(access.qualifiedName(), access.isProtected());
    505505    }
     
    507507    inh ResolvedAccess SrcAccess.simpleLookupBypassDot(String name);
    508508    eq BaseNode.getChild(int i).simpleLookupBypassDot(String name) = getChild(i).simpleLookupHelper(name);
    509     eq SrcDot.getSrcAccess().simpleLookupBypassDot(String name)    = simpleLookupHelper(name);
     509    eq SrcDot.getSrcNamedAccess().simpleLookupBypassDot(String name)    = simpleLookupHelper(name);
    510510
    511511
  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/jastadd/source/SourceTraversal.jrag

    r10849 r13095  
    266266     * Iterable over each part of a qualified name.
    267267     */
    268     syn Iterable<SrcAccess> SrcAccess.nameParts();
     268    syn Iterable<? extends SrcAccess> SrcAccess.nameParts();
    269269    eq SrcAccess.nameParts()       = new SingleIterable(this);
    270270    eq SrcGlobalAccess.nameParts() = getSrcAccess().nameParts();
    271     eq SrcDot.nameParts()          = getSrcAccesss();
     271    eq SrcDot.nameParts()          = getSrcNamedAccesss();
    272272
    273273    public <T extends SrcClause> Iterable<T> SrcClassDecl.clauses(Class<T> type) {
  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/jastadd/util/Util.jrag

    r12883 r13095  
    701701  syn lazy String SrcDot.name() {
    702702      StringBuilder buf = new StringBuilder();
    703       List<SrcAccess> l = getSrcAccessListNoTransform();
     703      List<SrcNamedAccess> l = getSrcNamedAccessListNoTransform();
    704704      for (int i = 0; i < l.getNumChildNoTransform(); i++) {
    705705          buf.append(l.getChildNoTransform(i).name());
     
    730730    eq SrcDot.qualifiedName() {
    731731        StringBuilder buf = new StringBuilder();
    732         for (SrcAccess a : getSrcAccesss()) {
     732        for (SrcNamedAccess a : getSrcNamedAccesss()) {
    733733            buf.append(a.qualifiedName());
    734734            buf.append('.');
     
    763763 
    764764  syn String SrcAccess.lastName() = name();
    765   eq SrcDot.lastName()            = getSrcAccessListNoTransform().lastChildNoTransform().lastName();
     765  eq SrcDot.lastName()            = getSrcNamedAccessListNoTransform().lastChildNoTransform().lastName();
    766766  eq SrcGlobalAccess.lastName()   = getSrcAccessNoTransform().lastName();
    767767 
     
    948948     */
    949949    syn SrcAccess SrcAccess.getLastAccess() = this;
    950     eq SrcDot.getLastAccess()            = getSrcAccess(getNumSrcAccess() - 1);
     950    eq SrcDot.getLastAccess()            = getSrcNamedAccess(getNumSrcNamedAccess() - 1);
    951951    eq SrcGlobalAccess.getLastAccess()   = getSrcAccess().getLastAccess();
    952952   
     
    960960     */
    961961    syn SrcAccess SrcAccess.getFirstAccess() = this;
    962     eq SrcDot.getFirstAccess()            = getSrcAccess(0);
     962    eq SrcDot.getFirstAccess()            = getSrcNamedAccess(0);
    963963    eq SrcGlobalAccess.getFirstAccess()   = getSrcAccess().getFirstAccess();
    964964
     
    969969   
    970970    inh SrcAccess SrcAccess.getNextAccess();
    971     eq SrcDot.getSrcAccess(int i).getNextAccess()    = (i >= getNumSrcAccess() - 1) ? null : getSrcAccess(i + 1);
     971    eq SrcDot.getSrcNamedAccess(int i).getNextAccess()    = (i >= getNumSrcNamedAccess() - 1) ? null : getSrcNamedAccess(i + 1);
    972972    eq SourceRoot.getProgram().getNextAccess() = computeNextAccess();
    973973    eq Root.getChild().getNextAccess()         = null;
     
    10091009   
    10101010    public SrcAccess SrcDot.stripFirstAccess() {
    1011         int n = getNumSrcAccess();
     1011        int n = getNumSrcNamedAccess();
    10121012        if (n <= 2)
    1013             return getSrcAccess(n - 1);
    1014         List<SrcAccess> l = new List<SrcAccess>();
     1013            return getSrcNamedAccess(n - 1);
     1014        List<SrcNamedAccess> l = new List<>();
    10151015        for (int i = 1; i < n; i++)
    1016             l.add(getSrcAccess(i));
     1016            l.add(getSrcNamedAccess(i));
    10171017        return new SrcDot(l);
    10181018    }
     
    10561056    inh boolean SrcAccess.inQualified();
    10571057    inh boolean InstAccess.inQualified();
    1058     eq SrcDot.getSrcAccess().inQualified()         = true;
     1058    eq SrcDot.getSrcNamedAccess().inQualified()         = true;
    10591059    eq InstDot.getInstAccess().inQualified() = true;
    10601060    eq BaseNode.getChild().inQualified()     = false;
  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/Arguments.java

    r11785 r13095  
    206206                "  -modelicapath=<path to modelica libraries> \n" +
    207207                "  -optfile=<path to XML options file> -opt=opt1:val1,opt2:val2\n" +
    208                 "  -target=<fmume, me ,fmucs, cs, jmu, fmux, parse or check>\n" +
     208                "  -target=<fmume, me, fmucs, cs, jmu, fmux, parse or check>\n" +
    209209                "  -version=<1.0 or 2.0>\n" +
    210210                "  -dumpmemuse[=<resolution>] -findflatinst \n" +
  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/SizeNode.java

  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/SizeTree.java

  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/collections/ListUtil.java

    r12934 r13095  
    9494
    9595    /**
    96      * Combines several lists into one.
     96     * Create a new list that is the concatenation of the given lists, in the order given.
    9797     *
    98      * @param lists The lists to join.
    99      * @return      one list containing all the elements in {@code lists}.
     98     * @param lists  any number of lists to concatenate
     99     * @return       a newly created ArrayList that contains the concatenation of the given lists
    100100     */
    101101    @SafeVarargs
    102     public static <T> List<T> join(List<T>... lists) {
    103         List<T> result = new ArrayList<T>();
     102    public static <T> ArrayList<T> concatenate(List<T>... lists) {
     103        int size = 0;
    104104        for (List<T> list : lists) {
    105             result.addAll(list);
     105            size += list.size();
    106106        }
    107         return result;
     107        ArrayList<T> res = new ArrayList<T>(size);
     108        for (List<T> list : lists) {
     109            res.addAll(list);
     110        }
     111        return res;
    108112    }
    109113
  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/src/parser/Modelica.parser

    r13009 r13095  
    16471647      access_single
    16481648    {:
    1649         access_dot.addSrcAccess(access_single);
     1649        access_dot.addSrcNamedAccess(access_single);
    16501650        return access_dot;
    16511651    :}
     
    16871687      access_single_scalar
    16881688    {:
    1689         access_scalar_dot.addSrcAccess(access_single_scalar);
     1689        access_scalar_dot.addSrcNamedAccess(access_single_scalar);
    16901690        return access_scalar_dot;
    16911691    :}
  • branches/dev-mj-1626/Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo

    r12934 r13095  
    1515*/
    1616
     17within;
    1718
    1819package ExpandableConnectors
     
    2122        expandable connector EC
    2223        end EC;
    23        
    24         connector C = Real;
    25        
     24
     25        connector C = Real;
     26
    2627        EC ec1, ec2, ec3;
    2728        C c1, c2;
     
    5859        expandable connector EC
    5960        end EC;
    60        
     61
    6162        connector C
    6263            Real a;
     
    123124end ExpandableConnectors.Expandable2;
    124125")})));
    125     end Expandable2;
     126    end Expandable2;
    126127
    127128
     
    129130        expandable connector EC
    130131        end EC;
    131        
     132
    132133        connector C = Real[2];
    133        
     134
    134135        model M
    135136            EC ec1, ec2, ec3;
     
    141142            connect(ec3.a, c2);
    142143        end M;
    143        
     144
    144145        M m[2];
    145146
     
    188189        expandable connector EC
    189190        end EC;
    190        
    191         connector C = Real;
    192        
    193         EC ec[3];
    194         C c1, c2;
    195     equation
    196         connect(c1, ec[1].a);
    197         connect(ec[1], ec[2]);
    198         connect(ec[2], ec[3]);
    199         connect(ec[3].a, c2);
    200 
    201     annotation(__JModelica(UnitTesting(tests={
    202         FlatteningTestCase(
    203             name="Expandable4",
    204             description="Array of expandable connectors",
    205             flatModel="
    206 fclass ExpandableConnectors.Expandable4
    207  Real ec[1].a;
    208  Real ec[2].a;
    209  Real ec[3].a;
    210  Real c1;
    211  Real c2;
    212 equation
    213  c1 = c2;
    214  c2 = ec[1].a;
    215  ec[1].a = ec[2].a;
    216  ec[2].a = ec[3].a;
    217 end ExpandableConnectors.Expandable4;
    218 ")})));
    219     end Expandable4;
    220    
    221    
    222     model Expandable5
    223         expandable connector EC
    224         end EC;
    225        
    226         connector C = Real;
    227        
    228         model M
    229             C c;
    230         end M;
    231        
    232         parameter Integer n = 4;
    233        
    234         EC ec[n];
    235         M m[n];
    236     equation
    237         for i in 1:(n-2) loop
    238             connect(ec[i], ec[i+2]);
    239             connect(ec[i].a, m[i].c);
    240         end for;
    241         connect(ec[end-1].a, m[end-1].c);
    242         connect(ec[end].a, m[end].c);
    243 
    244     annotation(__JModelica(UnitTesting(tests={
    245         FlatteningTestCase(
    246             name="Expandable5",
    247             description="Connecting to expandable connector in for loop",
    248             flatModel="
    249 fclass ExpandableConnectors.Expandable5
    250  structural parameter Integer n = 4 /* 4 */;
    251  Real ec[1].a;
    252  Real ec[2].a;
    253  Real ec[3].a;
    254  Real ec[4].a;
    255  Real m[1].c;
    256  Real m[2].c;
    257  Real m[3].c;
    258  Real m[4].c;
    259 equation
    260  ec[1].a = ec[3].a;
    261  ec[3].a = m[1].c;
    262  m[1].c = m[3].c;
    263  ec[2].a = ec[4].a;
    264  ec[4].a = m[2].c;
    265  m[2].c = m[4].c;
    266 end ExpandableConnectors.Expandable5;
    267 ")})));
    268     end Expandable5;
    269    
    270    
    271     model Expandable7
    272         expandable connector EC
    273         end EC;
    274        
    275         model A
    276             replaceable EC ec;
    277         end A;
    278        
    279         connector C = Real;
    280        
    281         A a1(redeclare EC ec);
     191
     192        model A
     193            replaceable EC ec;
     194        end A;
     195
     196        connector C = Real;
     197
     198        A a1(redeclare EC ec);
    282199        A a2(redeclare EC ec);
    283200        A a3(redeclare EC ec);
     
    291208    annotation(__JModelica(UnitTesting(tests={
    292209        FlatteningTestCase(
    293             name="Expandable7",
     210            name="Expandable4",
    294211            description="Added support for redeclaring expandable connectors",
    295212            flatModel="
    296 fclass ExpandableConnectors.Expandable7
     213fclass ExpandableConnectors.Expandable4
    297214 Real a1.ec.b;
    298215 Real a2.ec.b;
     
    305222 a3.ec.b = c1;
    306223 c1 = c2;
    307 end ExpandableConnectors.Expandable7;
    308 ")})));
    309     end Expandable7;
    310 
    311 
    312     model Expandable8
    313         expandable connector EC
    314         end EC;
    315        
    316         connector C = Real;
    317        
     224end ExpandableConnectors.Expandable4;
     225")})));
     226    end Expandable4;
     227
     228
     229    model Expandable5
     230        expandable connector EC
     231        end EC;
     232
     233        connector C = Real;
     234
    318235        EC ec1, ec2, ec3;
    319236        C c1 = 1;
     
    327244    annotation(__JModelica(UnitTesting(tests={
    328245        FlatteningTestCase(
    329             name="Expandable8",
     246            name="Expandable5",
    330247            description="Adding to expandable connectors from var with binding exp",
    331248            flatModel="
    332 fclass ExpandableConnectors.Expandable8
     249fclass ExpandableConnectors.Expandable5
    333250 Real ec1.a;
    334251 Real ec2.a;
     
    341258 ec1.a = ec2.a;
    342259 ec2.a = ec3.a;
    343 end ExpandableConnectors.Expandable8;
    344 ")})));
    345     end Expandable8;
    346 
    347 
    348     model Expandable8b
    349         expandable connector EC
    350         end EC;
    351        
     260end ExpandableConnectors.Expandable5;
     261")})));
     262    end Expandable5;
     263
     264
     265    model Expandable5b
     266        expandable connector EC
     267        end EC;
     268
    352269        connector C
    353             Real x;
    354             Real y;
    355         end C;
    356        
     270            Real x;
     271            Real y;
     272        end C;
     273
    357274        EC ec1, ec2, ec3;
    358275        C c1(x = 1, y = 2);
     
    366283    annotation(__JModelica(UnitTesting(tests={
    367284        FlatteningTestCase(
    368             name="Expandable8b",
     285            name="Expandable5b",
    369286            description="Adding to expandable connectors from composite with binding exps",
    370287            flatModel="
    371 fclass ExpandableConnectors.Expandable8b
     288fclass ExpandableConnectors.Expandable5b
    372289 Real ec1.a.x;
    373290 Real ec1.a.y;
     
    389306 ec1.a.y = ec2.a.y;
    390307 ec2.a.y = ec3.a.y;
    391 end ExpandableConnectors.Expandable8b;
    392 ")})));
    393     end Expandable8b;
    394    
    395    
    396     model Expandable9
    397         expandable connector EC
    398         end EC;
    399        
     308end ExpandableConnectors.Expandable5b;
     309")})));
     310    end Expandable5b;
     311
     312
     313    model Expandable6
     314        expandable connector EC
     315        end EC;
     316
    400317        connector C = Real;
    401318       
     
    410327    annotation(__JModelica(UnitTesting(tests={
    411328        FlatteningTestCase(
    412             name="Expandable9",
     329            name="Expandable6",
    413330            description="Expandable connectors: connect to single element in array",
    414331            flatModel="
    415 fclass ExpandableConnectors.Expandable9
     332fclass ExpandableConnectors.Expandable6
    416333 Real ec1.a;
    417334 Real ec2.a;
     
    423340 ec1.a = ec2.a;
    424341 ec2.a = ec3.a;
    425 end ExpandableConnectors.Expandable9;
    426 ")})));
    427     end Expandable9;
    428    
    429    
    430     model Expandable10
    431         expandable connector EC
    432         end EC;
    433        
    434         connector C = Real;
    435        
     342end ExpandableConnectors.Expandable6;
     343")})));
     344    end Expandable6;
     345
     346
     347    model Expandable7
     348        expandable connector EC
     349        end EC;
     350
     351        connector C = Real;
     352
    436353        EC ec1, ec2, ec3;
    437354        C c[4];
     
    444361    annotation(__JModelica(UnitTesting(tests={
    445362        FlatteningTestCase(
    446             name="Expandable10",
     363            name="Expandable7",
    447364            description="Expandable connectors: connect to slice",
    448365            flatModel="
    449 fclass ExpandableConnectors.Expandable10
     366fclass ExpandableConnectors.Expandable7
    450367 Real ec1.a[2];
    451368 Real ec2.a[2];
     
    461378 ec1.a[2] = ec2.a[2];
    462379 ec2.a[2] = ec3.a[2];
    463 end ExpandableConnectors.Expandable10;
    464 ")})));
    465     end Expandable10;
    466 
    467 
    468     model Expandable11
    469         expandable connector EC
    470         end EC;
    471        
    472         connector C = Real;
    473        
     380end ExpandableConnectors.Expandable7;
     381")})));
     382    end Expandable7;
     383
     384
     385    model Expandable8
     386        expandable connector EC
     387        end EC;
     388
     389        connector C = Real;
     390
    474391        EC ec1, ec2, ec3;
    475392        C c1, c2, c3, c4;
     
    484401    annotation(__JModelica(UnitTesting(tests={
    485402        FlatteningTestCase(
    486             name="Expandable11",
     403            name="Expandable8",
    487404            description="Connecting to cell of array in expandable connector",
    488405            flatModel="
    489 fclass ExpandableConnectors.Expandable11
     406fclass ExpandableConnectors.Expandable8
    490407 Real ec1.a[2];
    491408 Real ec2.a[2];
     
    504421 ec1.a[2] = ec2.a[2];
    505422 ec2.a[2] = ec3.a[2];
    506 end ExpandableConnectors.Expandable11;
    507 ")})));
    508     end Expandable11;
    509 
    510 
    511     model Expandable12
    512         expandable connector EC
    513         end EC;
    514        
    515         connector C = Real;
    516        
     423end ExpandableConnectors.Expandable8;
     424")})));
     425    end Expandable8;
     426
     427
     428    model Expandable9
     429        connector C = Real;
     430
     431        expandable connector EC
     432            C x;
     433        end EC;
     434
     435        EC ec1, ec2;
     436        C x = time;
     437    equation
     438        connect(ec1.x, ec2.x);
     439        connect(ec1.x, x);
     440
     441    annotation(__JModelica(UnitTesting(tests={
     442        FlatteningTestCase(
     443            name="Expandable9",
     444            description="Connecting two declared members of expandable connectors",
     445            flatModel="
     446fclass ExpandableConnectors.Expandable9
     447 Real ec1.x;
     448 Real ec2.x;
     449 Real x = time;
     450equation
     451 ec1.x = ec2.x;
     452 ec2.x = x;
     453end ExpandableConnectors.Expandable9;
     454")})));
     455    end Expandable9;
     456
     457
     458    model Expandable10
     459        expandable connector EC
     460        end EC;
     461
     462        connector C = Real;
     463
    517464        EC ec1, ec2, ec3;
    518465        C c1[5], c2[5];
     
    527474    annotation(__JModelica(UnitTesting(tests={
    528475        FlatteningTestCase(
    529             name="Expandable12",
     476            name="Expandable10",
    530477            description="Connecting to slice of array in expandable connector",
    531478            flatModel="
    532 fclass ExpandableConnectors.Expandable12
     479fclass ExpandableConnectors.Expandable10
    533480 Real ec1.a[4];
    534481 Real ec2.a[4];
     
    553500 ec1.a[4] = ec2.a[4];
    554501 ec2.a[4] = ec3.a[4];
    555 end ExpandableConnectors.Expandable12;
    556 ")})));
    557     end Expandable12;
    558 
    559 
    560     model Expandable13
    561         expandable connector EC
    562         end EC;
    563        
    564         connector C = Real;
    565        
     502end ExpandableConnectors.Expandable10;
     503")})));
     504    end Expandable10;
     505
     506
     507    model Expandable11
     508        expandable connector EC
     509        end EC;
     510
     511        connector C = Real;
     512
    566513        EC ec1, ec2;
    567         C c1[2], c2[2,2];
    568     equation
     514        C c1[2], c2[2,2];
     515    equation
    569516        connect(ec1, ec2);
    570517        connect(ec1.a[1,:], c1);
     
    573520    annotation(__JModelica(UnitTesting(tests={
    574521        FlatteningTestCase(
    575             name="Expandable13",
     522            name="Expandable11",
    576523            description="Connecting to slice with colon of array in expandable connector",
    577524            flatModel="
    578 fclass ExpandableConnectors.Expandable13
     525fclass ExpandableConnectors.Expandable11
    579526 Real ec1.a[1,2];
    580527 Real ec1.b[2,2];
     
    596543 c2[2,2] = ec1.b[2,2];
    597544 ec1.b[2,2] = ec2.b[2,2];
    598 end ExpandableConnectors.Expandable13;
    599 ")})));
    600     end Expandable13;
    601    
    602    
    603     model Expandable14
    604         expandable connector EC
    605         end EC;
    606        
    607         connector C = Real;
    608        
     545end ExpandableConnectors.Expandable11;
     546")})));
     547    end Expandable11;
     548
     549
     550    model Expandable12
     551        expandable connector EC
     552        end EC;
     553
     554        connector C = Real;
     555
    609556        EC ec1;
    610557        C c1[3], c2;
     
    615562    annotation(__JModelica(UnitTesting(tests={
    616563        FlatteningTestCase(
    617             name="Expandable14",
     564            name="Expandable12",
    618565            description="Connecting to entire array and to single element",
    619566            flatModel="
    620 fclass ExpandableConnectors.Expandable14
     567fclass ExpandableConnectors.Expandable12
    621568 Real ec1.a[3];
    622569 Real c1[3];
     
    627574 c1[3] = c2;
    628575 c2 = ec1.a[3];
    629 end ExpandableConnectors.Expandable14;
    630 ")})));
    631     end Expandable14;
    632    
    633    
    634     model Expandable15
    635         expandable connector EC
    636             Real x;
    637             Real y;
    638         end EC;
    639        
    640         connector C = Real;
    641        
    642         EC ec;
    643         C c;
    644     equation
    645         connect(c, ec.x);
    646 
    647     annotation(__JModelica(UnitTesting(tests={
    648         FlatteningTestCase(
    649             name="Expandable15",
     576end ExpandableConnectors.Expandable12;
     577")})));
     578    end Expandable12;
     579
     580
     581    model Expandable13
     582        expandable connector EC
     583            Real x;
     584            Real y;
     585        end EC;
     586
     587        connector C = Real;
     588
     589        EC ec;
     590        C c;
     591    equation
     592        connect(c, ec.x);
     593
     594    annotation(__JModelica(UnitTesting(tests={
     595        FlatteningTestCase(
     596            name="Expandable13",
    650597            description="Expandable connector with members",
    651598            flatModel="
    652 fclass ExpandableConnectors.Expandable15
     599fclass ExpandableConnectors.Expandable13
    653600 Real ec.x;
    654601 Real c;
    655602equation
    656603 c = ec.x;
    657 end ExpandableConnectors.Expandable15;
    658 ")})));
    659     end Expandable15;
    660    
    661    
    662     model Expandable16
     604end ExpandableConnectors.Expandable13;
     605")})));
     606    end Expandable13;
     607
     608
     609    model Expandable14
    663610        expandable connector EC
    664611            Real a[3];
    665612        end EC;
    666        
    667         connector C = Real;
    668        
     613
     614        connector C = Real;
     615
    669616        EC ec;
    670617        C c[3];
     
    674621    annotation(__JModelica(UnitTesting(tests={
    675622        FlatteningTestCase(
    676             name="Expandable16",
     623            name="Expandable14",
    677624            description="Expandable connector with members: array",
    678625            flatModel="
    679 fclass ExpandableConnectors.Expandable16
     626fclass ExpandableConnectors.Expandable14
    680627 Real ec.a[3];
    681628 Real c[3];
     
    684631 c[2] = ec.a[2];
    685632 c[3] = ec.a[3];
    686 end ExpandableConnectors.Expandable16;
    687 ")})));
    688     end Expandable16;
    689    
    690    
    691     model Expandable17
     633end ExpandableConnectors.Expandable14;
     634")})));
     635    end Expandable14;
     636
     637
     638    model Expandable15
    692639        expandable connector EC
    693640            C a;
    694641        end EC;
    695        
     642
    696643        connector C
    697644            Real x;
    698645            Real y;
    699646        end C;
    700        
     647
    701648        EC ec;
    702649        C c;
     
    706653    annotation(__JModelica(UnitTesting(tests={
    707654        FlatteningTestCase(
    708             name="Expandable17",
     655            name="Expandable15",
    709656            description="Expandable connector with members: composite",
    710657            flatModel="
    711 fclass ExpandableConnectors.Expandable17
     658fclass ExpandableConnectors.Expandable15
    712659 Real ec.a.x;
    713660 Real ec.a.y;
     
    717664 c.x = ec.a.x;
    718665 c.y = ec.a.y;
    719 end ExpandableConnectors.Expandable17;
    720 ")})));
    721     end Expandable17;
    722    
    723    
    724     model Expandable18
     666end ExpandableConnectors.Expandable15;
     667")})));
     668    end Expandable15;
     669
     670
     671    model Expandable16
    725672        expandable connector EC
    726673            Real x;
    727674        end EC;
    728        
    729         connector C = Real;
    730        
    731         C c;
     675
     676        connector C = Real;
     677
     678        C c;
    732679        EC ec;
    733680        Real y;
    734681    equation
    735         connect(c, ec.x);
     682        connect(c, ec.x);
    736683        y = ec.x;
    737684
    738685    annotation(__JModelica(UnitTesting(tests={
    739686        FlatteningTestCase(
    740             name="Expandable18",
     687            name="Expandable16",
    741688            description="Using member of expandable connector that is connected to",
    742689            flatModel="
    743 fclass ExpandableConnectors.Expandable18
     690fclass ExpandableConnectors.Expandable16
    744691 Real c;
    745692 Real ec.x;
     
    748695 y = ec.x;
    749696 c = ec.x;
    750 end ExpandableConnectors.Expandable18;
    751 ")})));
    752     end Expandable18;
    753    
    754    
    755     model Expandable19
     697end ExpandableConnectors.Expandable16;
     698")})));
     699    end Expandable16;
     700
     701
     702    model Expandable17
    756703        expandable connector EC
    757704            Real x;
     
    768715    annotation(__JModelica(UnitTesting(tests={
    769716        FlatteningTestCase(
    770             name="Expandable19",
     717            name="Expandable17",
    771718            description="Using member of expandable connector that is connected to",
    772719            flatModel="
    773 fclass ExpandableConnectors.Expandable19
     720fclass ExpandableConnectors.Expandable17
    774721 Real c;
    775722 Real ec.x;
     
    777724equation
    778725 c = ec.x;
    779 end ExpandableConnectors.Expandable19;
    780 ")})));
    781     end Expandable19;
    782    
    783    
    784     model Expandable20
     726end ExpandableConnectors.Expandable17;
     727")})));
     728    end Expandable17;
     729
     730
     731    model Expandable18
    785732        expandable connector EC
    786733            Real x;
     
    801748    annotation(__JModelica(UnitTesting(tests={
    802749        FlatteningTestCase(
    803             name="Expandable20",
     750            name="Expandable18",
    804751            description="Using member of expandable connector that is connected to",
    805752            flatModel="
    806 fclass ExpandableConnectors.Expandable20
     753fclass ExpandableConnectors.Expandable18
    807754 Real c;
    808755 Real ec.x;
     
    810757equation
    811758 c = ec.x;
     759end ExpandableConnectors.Expandable18;
     760")})));
     761    end Expandable18;
     762
     763
     764    model Expandable19
     765        expandable connector EC1
     766            Real x;
     767        end EC1;
     768
     769        expandable connector EC2
     770        end EC2;
     771
     772        connector C = Real;
     773
     774        C c;
     775        EC1 ec1a, ec1b;
     776        EC2 ec2;
     777        Real y;
     778    equation
     779        connect(ec1a, ec1b);
     780        connect(ec1b, ec2);
     781        connect(c, ec2.x);
     782        y = ec1b.x;
     783
     784    annotation(__JModelica(UnitTesting(tests={
     785        FlatteningTestCase(
     786            name="Expandable19",
     787            description="Using member of expandable connector that is connected to",
     788            flatModel="
     789fclass ExpandableConnectors.Expandable19
     790 Real c;
     791 Real ec1a.x;
     792 Real ec1b.x;
     793 Real ec2.x;
     794 Real y;
     795equation
     796 y = ec1b.x;
     797 c = ec1a.x;
     798 ec1a.x = ec1b.x;
     799 ec1b.x = ec2.x;
     800end ExpandableConnectors.Expandable19;
     801")})));
     802    end Expandable19;
     803
     804
     805    model Expandable20
     806        expandable connector EC1
     807            Real x;
     808        end EC1;
     809
     810        expandable connector EC2
     811        end EC2;
     812
     813        connector C = Real;
     814
     815        C c;
     816        EC1 ec1a, ec1b;
     817        EC2 ec2;
     818        Real y = ec1b.x;
     819    equation
     820        connect(ec1a, ec1b);
     821        connect(ec1b, ec2);
     822        connect(c, ec2.x);
     823
     824    annotation(__JModelica(UnitTesting(tests={
     825        FlatteningTestCase(
     826            name="Expandable20",
     827            description="Using member of expandable connector that is connected to",
     828            flatModel="
     829fclass ExpandableConnectors.Expandable20
     830 Real c;
     831 Real ec1a.x;
     832 Real ec1b.x;
     833 Real ec2.x;
     834 Real y = ec1b.x;
     835equation
     836 c = ec1a.x;
     837 ec1a.x = ec1b.x;
     838 ec1b.x = ec2.x;
    812839end ExpandableConnectors.Expandable20;
    813840")})));
    814841    end Expandable20;
    815    
    816    
     842
     843
    817844    model Expandable21
    818845        expandable connector EC1
    819846            Real x;
    820847        end EC1;
    821        
     848
    822849        expandable connector EC2
    823850        end EC2;
    824        
    825         connector C = Real;
    826        
     851
     852        model A
     853            Real y;
     854        end A;
     855
     856        connector C = Real;
     857
    827858        C c;
    828859        EC1 ec1a, ec1b;
    829860        EC2 ec2;
    830         Real y;
     861        A a(y = ec1b.x);
    831862    equation
    832863        connect(ec1a, ec1b);
    833864        connect(ec1b, ec2);
    834865        connect(c, ec2.x);
    835         y = ec1b.x;
    836866
    837867    annotation(__JModelica(UnitTesting(tests={
     
    845875 Real ec1b.x;
    846876 Real ec2.x;
    847  Real y;
    848 equation
    849  y = ec1b.x;
     877 Real a.y = ec1b.x;
     878equation
    850879 c = ec1a.x;
    851880 ec1a.x = ec1b.x;
     
    854883")})));
    855884    end Expandable21;
    856    
    857    
     885
     886
    858887    model Expandable22
    859         expandable connector EC1
    860             Real x;
    861         end EC1;
    862        
    863         expandable connector EC2
    864         end EC2;
    865        
    866         connector C = Real;
    867        
    868         C c;
    869         EC1 ec1a, ec1b;
    870         EC2 ec2;
    871         Real y = ec1b.x;
    872     equation
    873         connect(ec1a, ec1b);
    874         connect(ec1b, ec2);
    875         connect(c, ec2.x);
    876 
    877     annotation(__JModelica(UnitTesting(tests={
    878         FlatteningTestCase(
    879             name="Expandable22",
    880             description="Using member of expandable connector that is connected to",
    881             flatModel="
    882 fclass ExpandableConnectors.Expandable22
    883  Real c;
    884  Real ec1a.x;
    885  Real ec1b.x;
    886  Real ec2.x;
    887  Real y = ec1b.x;
    888 equation
    889  c = ec1a.x;
    890  ec1a.x = ec1b.x;
    891  ec1b.x = ec2.x;
    892 end ExpandableConnectors.Expandable22;
    893 ")})));
    894     end Expandable22;
    895    
    896    
    897     model Expandable23
    898         expandable connector EC1
    899             Real x;
    900         end EC1;
    901        
    902         expandable connector EC2
    903         end EC2;
    904        
    905         model A
    906             Real y;
    907         end A;
    908        
    909         connector C = Real;
    910        
    911         C c;
    912         EC1 ec1a, ec1b;
    913         EC2 ec2;
    914         A a(y = ec1b.x);
    915     equation
    916         connect(ec1a, ec1b);
    917         connect(ec1b, ec2);
    918         connect(c, ec2.x);
    919 
    920     annotation(__JModelica(UnitTesting(tests={
    921         FlatteningTestCase(
    922             name="Expandable23",
    923             description="Using member of expandable connector that is connected to",
    924             flatModel="
    925 fclass ExpandableConnectors.Expandable23
    926  Real c;
    927  Real ec1a.x;
    928  Real ec1b.x;
    929  Real ec2.x;
    930  Real a.y = ec1b.x;
    931 equation
    932  c = ec1a.x;
    933  ec1a.x = ec1b.x;
    934  ec1b.x = ec2.x;
    935 end ExpandableConnectors.Expandable23;
    936 ")})));
    937     end Expandable23;
    938    
    939    
    940     model Expandable24
    941         expandable connector EC
    942         end EC;
    943        
    944         connector C = Real;
    945        
     888        expandable connector EC
     889        end EC;
     890
     891        connector C = Real;
     892
    946893        EC ec;
    947894        C c;
     
    951898    annotation(__JModelica(UnitTesting(tests={
    952899        FlatteningTestCase(
    953             name="Expandable24",
     900            name="Expandable22",
    954901            description="Expandable connectors: Connecting to only some elements of array",
    955902            flatModel="
    956 fclass ExpandableConnectors.Expandable24
     903fclass ExpandableConnectors.Expandable22
    957904 Real ec.x[2];
    958905 Real c;
     
    960907 c = ec.x[2];
    961908 ec.x[1] = 0.0;
    962 end ExpandableConnectors.Expandable24;
    963 ")})));
    964     end Expandable24;
    965    
    966    
    967     model Expandable25
     909end ExpandableConnectors.Expandable22;
     910")})));
     911    end Expandable22;
     912
     913
     914    model Expandable23
    968915        expandable connector EC
    969916            Real x[3];
    970917        end EC;
    971        
    972         connector C = Real;
    973        
    974         EC ec;
    975         C c;
    976     equation
    977         connect(c, ec.x[2]);
    978 
    979     annotation(__JModelica(UnitTesting(tests={
    980         FlatteningTestCase(
    981             name="Expandable25",
     918
     919        connector C = Real;
     920
     921        EC ec;
     922        C c;
     923    equation
     924        connect(c, ec.x[2]);
     925
     926    annotation(__JModelica(UnitTesting(tests={
     927        FlatteningTestCase(
     928            name="Expandable23",
    982929            description="Expandable connectors: Connecting to only some elements of array",
    983930            flatModel="
    984 fclass ExpandableConnectors.Expandable25
     931fclass ExpandableConnectors.Expandable23
    985932 Real ec.x[3];
    986933 Real c;
     
    989936 ec.x[1] = 0.0;
    990937 ec.x[3] = 0.0;
    991 end ExpandableConnectors.Expandable25;
    992 ")})));
    993     end Expandable25;
     938end ExpandableConnectors.Expandable23;
     939")})));
     940    end Expandable23;
    994941   
    995942
    996     model Expandable26
    997         expandable connector EC
    998         end EC;
    999        
     943    model Expandable24
     944        expandable connector EC
     945        end EC;
     946
    1000947        connector C
    1001948            Real x;
    1002949            Real y;
    1003950        end C;
    1004            
     951
    1005952        EC ec;
    1006953        C c;
     
    1010957    annotation(__JModelica(UnitTesting(tests={
    1011958        FlatteningTestCase(
    1012             name="Expandable26",
     959            name="Expandable24",
    1013960            description="Expandable connectors: Connecting to only some elements of array",
    1014961            flatModel="
    1015 fclass ExpandableConnectors.Expandable26
     962fclass ExpandableConnectors.Expandable24
    1016963 Real ec.x[1].x;
    1017964 Real ec.x[1].y;
     
    1025972 ec.x[1].x = 0.0;
    1026973 ec.x[1].y = 0.0;
    1027 end ExpandableConnectors.Expandable26;
    1028 ")})));
    1029     end Expandable26;
    1030    
    1031    
    1032     model Expandable27
     974end ExpandableConnectors.Expandable24;
     975")})));
     976    end Expandable24;
     977
     978
     979    model Expandable25
    1033980        expandable connector EC
    1034981            C x[3];
    1035982        end EC;
    1036        
     983
    1037984        connector C
    1038             Real x;
    1039             Real y;
    1040         end C;
    1041        
     985            Real x;
     986            Real y;
     987        end C;
     988
    1042989        EC ec;
    1043990        C c;
     
    1047994    annotation(__JModelica(UnitTesting(tests={
    1048995        FlatteningTestCase(
    1049             name="Expandable27",
     996            name="Expandable25",
    1050997            description="Expandable connectors: Connecting to only some elements of array",
    1051998            flatModel="
    1052 fclass ExpandableConnectors.Expandable27
     999fclass ExpandableConnectors.Expandable25
    10531000 Real ec.x[1].x;
    10541001 Real ec.x[1].y;
     
    10661013 ec.x[3].x = 0.0;
    10671014 ec.x[3].y = 0.0;
    1068 end ExpandableConnectors.Expandable27;
    1069 ")})));
    1070     end Expandable27;
    1071 
    1072 
    1073     model Expandable28
     1015end ExpandableConnectors.Expandable25;
     1016")})));
     1017    end Expandable25;
     1018
     1019
     1020    model Expandable26
    10741021        expandable connector EC1
    1075             EC2 ec2;
     1022            EC2 ec2;
    10761023        end EC1;
    1077        
     1024
    10781025        expandable connector EC2
    10791026        end EC2;
    1080        
    1081         connector C = Real;
    1082        
    1083         EC1 ec1;
     1027
     1028        connector C = Real;
     1029
     1030        EC1 ec1;
    10841031        C c;
    1085     equation
    1086         connect(c, ec1.ec2.a);
    1087 
    1088     annotation(__JModelica(UnitTesting(tests={
    1089         FlatteningTestCase(
    1090             name="Expandable28",
     1032    equation
     1033        connect(c, ec1.ec2.a);
     1034
     1035    annotation(__JModelica(UnitTesting(tests={
     1036        FlatteningTestCase(
     1037            name="Expandable26",
    10911038            description="Nested declared expandable connectors: basic test",
    10921039            flatModel="
    1093 fclass ExpandableConnectors.Expandable28
     1040fclass ExpandableConnectors.Expandable26
    10941041 Real ec1.ec2.a;
    10951042 Real c;
    10961043equation
    10971044 c = ec1.ec2.a;
    1098 end ExpandableConnectors.Expandable28;
    1099 ")})));
    1100     end Expandable28;
    1101 
    1102 
    1103     model Expandable30
     1045end ExpandableConnectors.Expandable26;
     1046")})));
     1047    end Expandable26;
     1048
     1049
     1050    model Expandable27
    11041051        expandable connector EC1
    11051052            C1 c1;
    11061053        end EC1;
    1107        
     1054
    11081055        connector C1
    11091056            EC2 ec2;
    11101057            Real x;
    11111058        end C1;
    1112        
     1059
    11131060        expandable connector EC2
    11141061        end EC2;
    1115        
     1062
    11161063        connector C2 = Real;
    1117        
     1064
    11181065        EC1 ec1;
    11191066        C2 c2;
     
    11211068    annotation(__JModelica(UnitTesting(tests={
    11221069        FlatteningTestCase(
    1123             name="Expandable30",
     1070            name="Expandable27",
    11241071            description="Nested declared expandable connectors: not connected to",
    11251072            flatModel="
    1126 fclass ExpandableConnectors.Expandable30
     1073fclass ExpandableConnectors.Expandable27
    11271074 Real c2;
    1128 end ExpandableConnectors.Expandable30;
    1129 ")})));
    1130     end Expandable30;
    1131 
    1132 
    1133     model Expandable31
     1075end ExpandableConnectors.Expandable27;
     1076")})));
     1077    end Expandable27;
     1078
     1079
     1080    model Expandable28
    11341081        expandable connector EC1
    11351082            EC2 ec2;
    11361083        end EC1;
    1137        
     1084
    11381085        expandable connector EC2
    11391086            EC3 ec3;
    11401087        end EC2;
    1141        
     1088
    11421089        expandable connector EC3
    11431090        end EC3;
    1144        
    1145         connector C = Real;
    1146        
     1091
     1092        connector C = Real;
     1093
    11471094        EC1 ec1;
    11481095        C c;
     
    11521099    annotation(__JModelica(UnitTesting(tests={
    11531100        FlatteningTestCase(
    1154             name="Expandable31",
     1101            name="Expandable28",
    11551102            description="Nested declared expandable connectors: three deep",
    11561103            flatModel="
    1157 fclass ExpandableConnectors.Expandable31
     1104fclass ExpandableConnectors.Expandable28
    11581105 Real ec1.ec2.ec3.a;
    11591106 Real c;
    11601107equation
    11611108 c = ec1.ec2.ec3.a;
    1162 end ExpandableConnectors.Expandable31;
    1163 ")})));
    1164     end Expandable31;
    1165 
    1166 
    1167     model Expandable32
     1109end ExpandableConnectors.Expandable28;
     1110")})));
     1111    end Expandable28;
     1112
     1113
     1114    model Expandable29
    11681115        expandable connector EC1
    11691116            EC2 ec2;
    11701117        end EC1;
    1171        
     1118
    11721119        expandable connector EC2
    11731120        end EC2;
    1174        
    1175         connector C = Real;
    1176        
     1121
     1122        connector C = Real;
     1123
    11771124        EC1 ec1;
    11781125        C c1, c2;
     
    11831130    annotation(__JModelica(UnitTesting(tests={
    11841131        FlatteningTestCase(
    1185             name="Expandable32",
     1132            name="Expandable29",
    11861133            description="Nested declared expandable connectors: adding members to both levels",
    11871134            flatModel="
    1188 fclass ExpandableConnectors.Expandable32
     1135fclass ExpandableConnectors.Expandable29
    11891136 Real ec1.b;
    11901137 Real ec1.ec2.a;
     
    11941141 c1 = ec1.ec2.a;
    11951142 c2 = ec1.b;
    1196 end ExpandableConnectors.Expandable32;
    1197 ")})));
    1198     end Expandable32;
    1199    
    1200    
    1201     model Expandable33
     1143end ExpandableConnectors.Expandable29;
     1144")})));
     1145    end Expandable29;
     1146
     1147
     1148    model Expandable30
    12021149        expandable connector EC1
    12031150            EC2 a;
    12041151        end EC1;
    1205        
     1152
    12061153        expandable connector EC2
    12071154        end EC2;
    1208        
    1209         connector C = Real;
    1210        
     1155
     1156        connector C = Real;
     1157
    12111158        EC1 ec1_1, ec1_2;
    12121159        EC2 ec2_1, ec2_2;
     
    12211168    annotation(__JModelica(UnitTesting(tests={
    12221169        FlatteningTestCase(
    1223             name="Expandable33",
     1170            name="Expandable30",
    12241171            description="Connect expandable connectors containing other expandable connectors",
    12251172            flatModel="
    1226 fclass ExpandableConnectors.Expandable33
     1173fclass ExpandableConnectors.Expandable30
    12271174 Real ec1_1.a.b;
    12281175 Real ec1_1.a.c;
     
    12441191 ec1_2.a.c = ec2_1.c;
    12451192 ec2_1.c = ec2_2.c;
    1246 end ExpandableConnectors.Expandable33;
    1247 ")})));
    1248     end Expandable33;
    1249 
    1250 
    1251     model Expandable34
    1252         expandable connector EC
    1253         end EC;
    1254        
    1255         connector C = Real;
    1256        
     1193end ExpandableConnectors.Expandable30;
     1194")})));
     1195    end Expandable30;
     1196
     1197
     1198    model Expandable31
     1199        expandable connector EC
     1200        end EC;
     1201
     1202        connector C = Real;
     1203
    12571204        model A
    12581205            EC ec;
    12591206        end A;
    1260        
     1207
    12611208        A a;
    12621209        EC ec;
     
    12691216    annotation(__JModelica(UnitTesting(tests={
    12701217        FlatteningTestCase(
    1271             name="Expandable34",
     1218            name="Expandable31",
    12721219            description="Make sure that extra equations aren't added for combinations of inner/outer connections",
    12731220            flatModel="
    1274 fclass ExpandableConnectors.Expandable34
     1221fclass ExpandableConnectors.Expandable31
    12751222 Real a.ec.b1[2];
    12761223 Real a.ec.b2[2];
     
    12881235 a.ec.b2[2] = c2[2];
    12891236 c2[2] = ec.b2[2];
    1290 end ExpandableConnectors.Expandable34;
    1291 ")})));
    1292     end Expandable34;
    1293 
    1294 
    1295     model Expandable35
    1296         connector C = Real;
    1297        
    1298         expandable connector EC
    1299             C x;
    1300         end EC;
    1301        
    1302         EC ec1, ec2;
    1303         C x = time;
    1304     equation
    1305         connect(ec1.x, ec2.x);
    1306         connect(ec1.x, x);
    1307 
    1308     annotation(__JModelica(UnitTesting(tests={
    1309         FlatteningTestCase(
    1310             name="Expandable35",
    1311             description="Connecting two declared members of expandable connectors",
    1312             flatModel="
    1313 fclass ExpandableConnectors.Expandable35
    1314  Real ec1.x;
    1315  Real ec2.x;
    1316  Real x = time;
    1317 equation
    1318  ec1.x = ec2.x;
    1319  ec2.x = x;
    1320 end ExpandableConnectors.Expandable35;
    1321 ")})));
    1322     end Expandable35;
    1323 
    1324 
    1325     model Expandable36
     1237end ExpandableConnectors.Expandable31;
     1238")})));
     1239    end Expandable31;
     1240
     1241    model Expandable32
    13261242        connector C = Real[2];
    1327        
    1328         expandable connector EC
    1329         end EC;
    1330        
     1243
     1244        expandable connector EC
     1245        end EC;
     1246
    13311247        EC ec1, ec2;
    13321248        C x = { time, 2 * time };
     
    13371253    annotation(__JModelica(UnitTesting(tests={
    13381254        FlatteningTestCase(
    1339             name="Expandable36",
     1255            name="Expandable32",
    13401256            description="Array in nested expandable connector",
    13411257            flatModel="
    1342 fclass ExpandableConnectors.Expandable36
    1343  ExpandableConnectors.Expandable36.C ec1.x[2];
    1344  ExpandableConnectors.Expandable36.C ec2.ec.x[2];
    1345  ExpandableConnectors.Expandable36.C x[2] = {time, 2 * time};
     1258fclass ExpandableConnectors.Expandable32
     1259 ExpandableConnectors.Expandable32.C ec1.x[2];
     1260 ExpandableConnectors.Expandable32.C ec2.ec.x[2];
     1261 ExpandableConnectors.Expandable32.C x[2] = {time, 2 * time};
    13461262equation
    13471263 ec1.x[1] = ec2.ec.x[1];
     
    13511267
    13521268public
    1353  type ExpandableConnectors.Expandable36.C = Real;
    1354 end ExpandableConnectors.Expandable36;
    1355 ")})));
    1356     end Expandable36;
    1357 
    1358     model Expandable37
     1269 type ExpandableConnectors.Expandable32.C = Real;
     1270end ExpandableConnectors.Expandable32;
     1271")})));
     1272    end Expandable32;
     1273
     1274
     1275    model Expandable33
    13591276        expandable connector EC
    13601277        end EC;
     
    13621279        EC ec1;
    13631280        C c1;
     1281
    13641282    equation
    13651283        connect(c1, ec1.a) annotation (Line(
     
    13711289    annotation(__JModelica(UnitTesting(tests={
    13721290        FlatteningTestCase(
    1373             name="Expandable37",
     1291            name="Expandable33",
    13741292            description="Test expandable connector and connect equation with annotation, caused crash bug",
    13751293            flatModel="
    1376 fclass ExpandableConnectors.Expandable37
     1294fclass ExpandableConnectors.Expandable33
    13771295 Real ec1.a;
    13781296 Real c1;
     
    13801298 c1 = time;
    13811299 c1 = ec1.a;
    1382 end ExpandableConnectors.Expandable37;
    1383 ")})));
    1384     end Expandable37;
    1385 
    1386    
    1387    
     1300end ExpandableConnectors.Expandable33;
     1301")})));
     1302    end Expandable33;
     1303
     1304
     1305model ExpandableWithInputOutput1
     1306    connector CI = input Real;
     1307    connector CO = output Real;
     1308    connector C = Real;
     1309
     1310    expandable connector EC
     1311    end EC;
     1312
     1313    EC ec;
     1314    CI ci1;
     1315    CO co1;
     1316    input C ci2;
     1317    output C co2;
     1318equation
     1319    connect(ci1, ec.ci1);
     1320    connect(ci2, ec.ci2);
     1321    connect(co1, ec.co1);
     1322    connect(co2, ec.co2);
     1323
     1324    annotation(__JModelica(UnitTesting(tests={
     1325        FlatteningTestCase(
     1326            name="ExpandableWithInputOutput1",
     1327            description="Created variables in expandable connectors shouldn't be considered top-level input/outputs",
     1328            flatModel="
     1329fclass ExpandableConnectors.ExpandableWithInputOutput1
     1330 ExpandableConnectors.ExpandableWithInputOutput1.CI ec.ci1;
     1331 Real ec.ci2;
     1332 ExpandableConnectors.ExpandableWithInputOutput1.CO ec.co1;
     1333 Real ec.co2;
     1334 input ExpandableConnectors.ExpandableWithInputOutput1.CI ci1;
     1335 output ExpandableConnectors.ExpandableWithInputOutput1.CO co1;
     1336 input Real ci2;
     1337 output Real co2;
     1338equation
     1339 ci1 = ec.ci1;
     1340 ci2 = ec.ci2;
     1341 co1 = ec.co1;
     1342 co2 = ec.co2;
     1343
     1344public
     1345 type ExpandableConnectors.ExpandableWithInputOutput1.CI = Real;
     1346 type ExpandableConnectors.ExpandableWithInputOutput1.CO = Real;
     1347end ExpandableConnectors.ExpandableWithInputOutput1;
     1348")})));
     1349end ExpandableWithInputOutput1;
     1350
     1351
     1352model FlowInExpandable1
     1353    connector C
     1354        Real p;
     1355        flow Real f;
     1356    end C;
     1357
     1358    expandable connector EC
     1359    end EC;
     1360
     1361    model A
     1362        B b;
     1363        EC ec;
     1364    equation
     1365        connect(b.c, ec.c);
     1366    end A;
     1367
     1368    model B
     1369        C c;
     1370    end B;
     1371
     1372    A a;
     1373    B b;
     1374    EC ec;
     1375equation
     1376    connect(a.ec, ec);
     1377    connect(b.c, ec.c);
     1378
     1379annotation(__JModelica(UnitTesting(tests={
     1380    FlatteningTestCase(
     1381        name="FlowInExpandable1",
     1382        description="Check that flow variables in expandable connectors get zero equations as needed",
     1383        flatModel="
     1384fclass ExpandableConnectors.FlowInExpandable1
     1385 Real a.b.c.p;
     1386 Real a.b.c.f;
     1387 Real a.ec.c.p;
     1388 Real a.ec.c.f;
     1389 Real b.c.p;
     1390 Real b.c.f;
     1391 Real ec.c.p;
     1392 Real ec.c.f;
     1393equation
     1394 a.b.c.f - a.ec.c.f = 0.0;
     1395 a.ec.c.f + b.c.f - ec.c.f = 0.0;
     1396 a.ec.c.p = b.c.p;
     1397 b.c.p = ec.c.p;
     1398 a.b.c.p = a.ec.c.p;
     1399 ec.c.f = 0.0;
     1400end ExpandableConnectors.FlowInExpandable1;
     1401")})));
     1402end FlowInExpandable1;
     1403
     1404
     1405package Error
     1406
    13881407    model ExpandableErr1
    13891408        expandable connector EC
    13901409        end EC;
    1391        
    1392         connector C = Real;
    1393        
     1410
     1411        connector C = Real;
     1412
    13941413        EC ec1;
    13951414        C c[3];
     
    14081427")})));
    14091428    end ExpandableErr1;
    1410    
    1411    
     1429
     1430
    14121431    model ExpandableErr2
    14131432        expandable connector EC
    14141433        end EC;
    1415        
     1434
    14161435        connector C = Real;
    14171436       
     
    14321451")})));
    14331452    end ExpandableErr2;
    1434    
    1435    
     1453
     1454
    14361455    model ExpandableErr3
    14371456        expandable connector EC
    14381457        end EC;
    1439        
    1440         connector C = Real;
    1441        
     1458
     1459        connector C = Real;
     1460
    14421461        EC ec1;
    14431462        C c[3,3];
     
    14561475")})));
    14571476    end ExpandableErr3;
    1458    
    1459    
     1477
     1478
    14601479    model ExpandableErr3b
    14611480        expandable connector EC
    14621481        end EC;
    1463        
    1464         connector C = Real;
    1465        
     1482
     1483        connector C = Real;
     1484
    14661485        EC ec1;
    14671486        C c[3,3];
     
    14801499")})));
    14811500    end ExpandableErr3b;
    1482    
    1483    
     1501
     1502
    14841503    model ExpandableErr4
    14851504        expandable connector EC
    14861505        end EC;
    1487        
    1488         connector C = Real;
    1489        
     1506
     1507        connector C = Real;
     1508
    14901509        EC ec1;
    14911510        C c1[3], c2;
     
    15051524")})));
    15061525    end ExpandableErr4;
    1507    
    1508    
     1526
     1527
    15091528    model ExpandableErr5
    15101529        expandable connector EC
    15111530        end EC;
    1512        
    1513         connector C = Real;
    1514        
     1531
     1532        connector C = Real;
     1533
    15151534        EC ec1;
    15161535        C c1[3], c2;
     
    15301549")})));
    15311550    end ExpandableErr5;
    1532    
    1533    
     1551
     1552
    15341553    model ExpandableErr6
    15351554        expandable connector EC
    15361555        end EC;
    1537        
    1538         connector C = Real;
    1539        
     1556
     1557        connector C = Real;
     1558
    15401559        EC ec1;
    15411560        C c1[3], c2;
     
    15551574")})));
    15561575    end ExpandableErr6;
    1557    
    1558    
     1576
     1577
    15591578    model ExpandableErr7
    15601579        expandable connector EC
    15611580        end EC;
    1562        
    1563         connector C = Real;
    1564        
     1581
     1582        connector C = Real;
     1583
    15651584        EC ec1;
    15661585        C c1[3], c2;
     
    15801599")})));
    15811600    end ExpandableErr7;
    1582    
    1583    
     1601
     1602
    15841603    model ExpandableErr8
    15851604        expandable connector EC
    15861605        end EC;
    1587        
    1588         connector C = Real;
    1589        
     1606
     1607        connector C = Real;
     1608
    15901609        EC ec1;
    15911610        C c1[3], c2[4];
     
    16051624")})));
    16061625    end ExpandableErr8;
    1607    
    1608    
    1609     model ExpandableErr9
    1610         expandable connector EC
    1611         end EC;
    1612        
     1626
     1627
     1628    model ExpandableErr9
     1629        expandable connector EC
     1630        end EC;
     1631
    16131632        connector C1
    16141633            Real x;
    16151634        end C1;
    1616        
     1635
    16171636        connector C2
    16181637            Real y;
    16191638        end C2;
    1620        
     1639       
    16211640        EC ec;
    16221641        C1 c1;
    1623         C2 c2;
    1624     equation
     1642        C2 c2;
     1643    equation
    16251644        connect(c1, ec.a);
    16261645        connect(c2, ec.a);
     
    16361655  Type of component introduced to external connector does not match other connections to same name in connection set or component declared in connector
    16371656")})));
    1638     end ExpandableErr9;
    1639    
    1640    
     1657    end ExpandableErr9;
     1658
     1659
    16411660    model ExpandableErr10
    16421661        expandable connector EC
    16431662        end EC;
    1644        
     1663
    16451664        connector C1 = Real;
    1646        
     1665
    16471666        connector C2 = Boolean;
    1648        
     1667
    16491668        EC ec;
    16501669        C1 c1;
     
    16651684")})));
    16661685    end ExpandableErr10;
    1667    
    1668    
     1686
     1687
    16691688    model ExpandableErr11
    16701689        expandable connector EC
    16711690            Real a;
    16721691        end EC;
    1673        
     1692
    16741693        connector C = Boolean;
    1675        
     1694
    16761695        EC ec;
    16771696        C c;
     
    16901709")})));
    16911710    end ExpandableErr11;
    1692    
    1693    
     1711
     1712
    16941713    model ExpandableErr12
    16951714        expandable connector EC
    16961715            Real a[3];
    16971716        end EC;
    1698        
    1699         connector C = Real;
    1700        
     1717
     1718        connector C = Real;
     1719
    17011720        EC ec;
    17021721        C c[3];
     
    17151734")})));
    17161735    end ExpandableErr12;
    1717    
    1718    
     1736
     1737
    17191738    model ExpandableErr13
    17201739        expandable connector EC1
    17211740            Real a;
    17221741        end EC1;
    1723        
     1742
    17241743        expandable connector EC2
    17251744        end EC2;
    1726        
     1745
    17271746        connector C = Boolean;
    1728        
     1747
    17291748        EC1 ec1;
    17301749        EC2 ec2;
     
    17451764")})));
    17461765    end ExpandableErr13;
    1747    
    1748    
     1766
     1767
    17491768    model ExpandableErr14
    17501769        expandable connector EC1
    17511770            Real a;
    17521771        end EC1;
    1753        
     1772
    17541773        expandable connector EC2
    17551774            Boolean a;
    17561775        end EC2;
    1757        
     1776
    17581777        EC1 ec1;
    17591778        EC2 ec2;
     
    17721791")})));
    17731792    end ExpandableErr14;
    1774    
    1775    
     1793
     1794
    17761795    model ExpandableErr15
    17771796        expandable connector EC1
    17781797            Real a[3];
    17791798        end EC1;
    1780        
     1799
    17811800        expandable connector EC2
    17821801            Real a[4];
    17831802        end EC2;
    1784        
     1803
    17851804        EC1 ec1;
    17861805        EC2 ec2;
     
    17991818")})));
    18001819    end ExpandableErr15;
    1801    
    1802    
     1820
     1821
    18031822    model ExpandableErr16
    18041823        expandable connector EC1
    18051824            Real a;
    18061825        end EC1;
    1807        
     1826
    18081827        expandable connector EC2
    18091828        end EC2;
    1810        
     1829
    18111830        expandable connector EC3
    18121831            Boolean a;
    18131832        end EC3;
    1814        
    1815         connector C = Real;
    1816        
     1833
     1834        connector C = Real;
     1835
    18171836        EC1 ec1;
    18181837        EC2 ec2;
    18191838        EC3 ec3;
    1820         C c;
     1839        C c;
    18211840    equation
    18221841        connect(ec1, ec2);
    18231842        connect(ec2, ec3);
    1824         connect(c, ec1.a);
     1843        connect(c, ec1.a);
    18251844
    18261845    annotation(__JModelica(UnitTesting(tests={
     
    18351854")})));
    18361855    end ExpandableErr16;
    1837    
    1838    
     1856
     1857
    18391858    model ExpandableErr17
    18401859        expandable connector EC1
    18411860            Real a[3];
    18421861        end EC1;
    1843        
     1862
    18441863        expandable connector EC2
    18451864        end EC2;
    1846        
     1865
    18471866        expandable connector EC3
    18481867            Real a[4];
    18491868        end EC3;
    1850        
    1851         connector C = Real;
    1852        
     1869
     1870        connector C = Real;
     1871
    18531872        EC1 ec1;
    18541873        EC2 ec2;
     
    18711890")})));
    18721891    end ExpandableErr17;
    1873    
    1874    
    1875     model ExpandableErr18
    1876         expandable connector EC
    1877             Real x;
    1878         end EC;
    1879        
    1880         connector C
    1881             Real x;
    1882         end C;
    1883        
    1884         EC ec;
    1885         C c;
    1886     equation
    1887         connect(ec, c);
     1892
     1893
     1894    model ExpandableErr18
     1895        expandable connector EC
     1896            Real x;
     1897        end EC;
     1898
     1899        connector C
     1900            Real x;
     1901        end C;
     1902
     1903        EC ec;
     1904        C c;
     1905    equation
     1906        connect(ec, c);
    18881907
    18891908    annotation(__JModelica(UnitTesting(tests={
     
    189419131 errors found:
    18951914
    1896 Error at line 13, column 3, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo', CONNECT_EXPANDABLE_AND_NON_EXPANDABLE_TYPE:
     1915Error at line 13, column 9, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo', CONNECT_EXPANDABLE_AND_NON_EXPANDABLE_TYPE:
    18971916  Connecting an expandable connector to a non-expandable connector is not allowed
    18981917")})));
    1899     end ExpandableErr18;
    1900    
    1901    
     1918    end ExpandableErr18;
     1919
     1920
    19021921    model ExpandableErr19
    19031922        expandable connector EC
     
    19211940")})));
    19221941    end ExpandableErr19;
    1923    
    1924    
     1942
     1943
    19251944    model ExpandableErr20
    19261945        expandable connector EC
     
    19421961")})));
    19431962    end ExpandableErr20;
    1944    
    1945    
     1963
     1964
    19461965    model ExpandableErr21
    19471966        expandable connector EC
    19481967            Real x;
    19491968        end EC;
    1950        
    1951         model A
    1952             Real y;
    1953         end A;
    1954        
     1969
     1970        model A
     1971            Real y;
     1972        end A;
     1973
    19551974        EC ec;
    19561975        A a(y = ec.x);
     
    19681987    end ExpandableErr21;
    19691988
     1989
    19701990model ExpandableErr22
    19711991    connector A
    19721992        Real x;
    19731993    end A;
    1974    
     1994
    19751995    connector B
    19761996        Real x;
    19771997        Real y;
    19781998    end B;
    1979    
     1999
    19802000    expandable connector C
    19812001    end C;
     
    20022022
    20032023
    2004     model ExpandableCompliance3
    2005         expandable connector EC
    2006         end EC;
    2007        
    2008         connector C = Real;
    2009        
     2024end Error;
     2025
     2026
     2027
     2028package Compliance
     2029
     2030    model ExpandableCompliance1
     2031        expandable connector EC
     2032        end EC;
     2033
     2034        connector C = Real;
     2035
    20102036        EC ec;
    2011         C c;
    2012     equation
     2037        C c;
     2038    equation
    20132039        connect(c, ec.a1.a2);
    2014         connect(ec.b1.b2, c);
     2040        connect(ec.b1.b2, c);
    20152041
    20162042    annotation(__JModelica(UnitTesting(tests={
    20172043        ComplianceErrorTestCase(
    2018             name="ExpandableCompliance3",
     2044            name="ExpandableCompliance1",
    20192045            description="Nested expandable connectors: connecting with more than one unknown name",
    20202046            errorMessage="
     
    20242050  Nested expandable connectors where some of the intermediate expandable connectors are neither connected to or declared are not supported
    20252051
    2026 Compliance error at line 11, column 11, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo':
     2052Compliance error at line 11, column 17, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo':
    20272053  Nested expandable connectors where some of the intermediate expandable connectors are neither connected to or declared are not supported
    20282054")})));
    2029     end ExpandableCompliance3;
    2030 
    2031 
    2032     model ExpandableCompliance4
    2033         expandable connector EC
    2034         end EC;
    2035        
     2055    end ExpandableCompliance1;
     2056
     2057
     2058    model ExpandableCompliance2
     2059        expandable connector EC
     2060        end EC;
     2061
    20362062        connector C
    20372063            EC ec;
    20382064        end C;
    2039        
     2065
    20402066        EC ec;
    20412067        C c;
     
    20452071    annotation(__JModelica(UnitTesting(tests={
    20462072        ComplianceErrorTestCase(
    2047             name="ExpandableCompliance4",
     2073            name="ExpandableCompliance2",
    20482074            description="Adding normal connector containing expandable connector to expandable connector",
    20492075            errorMessage="
     
    20532079  Expandable connectors containing a non-expandable connector component, that in turn contains an expandable connector, is not supported
    20542080")})));
    2055     end ExpandableCompliance4;
    2056 
     2081    end ExpandableCompliance2;
     2082
     2083end Compliance;
     2084
     2085
     2086
     2087package Nested
    20572088
    20582089    model NestedExpandable1
    20592090        expandable connector EC
    20602091        end EC;
    2061    
    2062         connector C = Real;
    2063    
     2092
     2093        connector C = Real;
     2094
    20642095        EC ec1;
    20652096        EC ec2;
     
    20742105            description="Adding expandable connector member to expandable connector, member of parent first",
    20752106            flatModel="
    2076 fclass ExpandableConnectors.NestedExpandable1
     2107fclass ExpandableConnectors.Nested.NestedExpandable1
    20772108 Real ec1.sub1.c;
    20782109 Real ec2.c;
     
    20812112 c = ec1.sub1.c;
    20822113 ec1.sub1.c = ec2.c;
    2083 end ExpandableConnectors.NestedExpandable1;
     2114end ExpandableConnectors.Nested.NestedExpandable1;
    20842115")})));
    20852116    end NestedExpandable1;
     
    20892120        expandable connector EC
    20902121        end EC;
    2091    
    2092         connector C = Real;
    2093    
     2122
     2123        connector C = Real;
     2124
    20942125        EC ec1;
    20952126        EC ec2;
     
    21042135            description="Adding expandable connector member to expandable connector, member of child first",
    21052136            flatModel="
    2106 fclass ExpandableConnectors.NestedExpandable2
     2137fclass ExpandableConnectors.Nested.NestedExpandable2
    21072138 Real ec1.sub1.c;
    21082139 Real ec2.c;
     
    21112142 c = ec1.sub1.c;
    21122143 ec1.sub1.c = ec2.c;
    2113 end ExpandableConnectors.NestedExpandable2;
     2144end ExpandableConnectors.Nested.NestedExpandable2;
    21142145")})));
    21152146    end NestedExpandable2;
     
    21192150        expandable connector EC
    21202151        end EC;
    2121        
    2122         connector C = Real;
    2123        
     2152
     2153        connector C = Real;
     2154
    21242155        EC ec1_1, ec1_2;
    21252156        EC ec2_1, ec2_2;
     
    21372168            description="Adding expandable connector member to expandable connector, more complicated test",
    21382169            flatModel="
    2139 fclass ExpandableConnectors.NestedExpandable3
     2170fclass ExpandableConnectors.Nested.NestedExpandable3
    21402171 Real ec1_1.a.b;
    21412172 Real ec1_1.a.c;
     
    21572188 ec1_2.a.c = ec2_1.c;
    21582189 ec2_1.c = ec2_2.c;
    2159 end ExpandableConnectors.NestedExpandable3;
     2190end ExpandableConnectors.Nested.NestedExpandable3;
    21602191")})));
    21612192    end NestedExpandable3;
     
    21652196        expandable connector EC
    21662197        end EC;
    2167        
     2198
    21682199        connector C = Real;
    21692200       
     
    21802211            description="Adding expandable connector member to expandable connector, several levels",
    21812212            flatModel="
    2182 fclass ExpandableConnectors.NestedExpandable4
     2213fclass ExpandableConnectors.Nested.NestedExpandable4
    21832214 Real ec1.ec2.ec3.a;
    21842215 Real ec2.ec3.a;
     
    21892220 ec1.ec2.ec3.a = ec2.ec3.a;
    21902221 ec2.ec3.a = ec3.a;
    2191 end ExpandableConnectors.NestedExpandable4;
     2222end ExpandableConnectors.Nested.NestedExpandable4;
    21922223")})));
    21932224    end NestedExpandable4;
     
    21972228        expandable connector EC
    21982229        end EC;
    2199        
    2200         connector C = Real;
    2201        
     2230
     2231        connector C = Real;
     2232
    22022233        EC ec1, ec2, ec3;
    22032234        C c;
     
    22122243            description="Adding expandable connector member to expandable connector, several levels, members first",
    22132244            flatModel="
    2214 fclass ExpandableConnectors.NestedExpandable5
     2245fclass ExpandableConnectors.Nested.NestedExpandable5
    22152246 Real ec1.ec2.ec3.a;
    22162247 Real ec2.ec3.a;
     
    22212252 ec1.ec2.ec3.a = ec2.ec3.a;
    22222253 ec2.ec3.a = ec3.a;
    2223 end ExpandableConnectors.NestedExpandable5;
     2254end ExpandableConnectors.Nested.NestedExpandable5;
    22242255")})));
    22252256    end NestedExpandable5;
     
    22292260        expandable connector EC
    22302261        end EC;
    2231        
     2262
    22322263        connector C1
    22332264            C2 a;
    22342265        end C1;
    2235    
     2266
    22362267        connector C2 = Real;
    2237    
     2268
    22382269        EC ec;
    22392270        C1 c1;
     
    22482279            description="Connecting to existing member of normal connector in expandable connector",
    22492280            flatModel="
    2250 fclass ExpandableConnectors.NestedExpandable6
     2281fclass ExpandableConnectors.Nested.NestedExpandable6
    22512282 Real ec.sub1.a;
    22522283 Real c1.a;
     
    22552286 c1.a = c2;
    22562287 c2 = ec.sub1.a;
    2257 end ExpandableConnectors.NestedExpandable6;
     2288end ExpandableConnectors.Nested.NestedExpandable6;
    22582289")})));
    22592290    end NestedExpandable6;
     
    22632294        expandable connector EC
    22642295        end EC;
    2265    
     2296
    22662297        connector C
    22672298            Real p;
    22682299            flow Real f;
    22692300        end C;
    2270    
     2301
    22712302        EC ec1, ec2;
    22722303        C c1[2], c2[2];
     
    22942325        expandable connector EC
    22952326        end EC;
    2296    
     2327
    22972328        EC ec1, ec2, ec3;
    22982329    equation
     
    23392370            description="Same expandable connector added as nested connector in two separate expandable connectors",
    23402371            flatModel="
    2341 fclass ExpandableConnectors.NestedExpandable9
     2372fclass ExpandableConnectors.Nested.NestedExpandable9
    23422373 Real ec1.c3;
    23432374 Real ec1.ec.c1;
     
    23582389 ec2.ec.c2 = ec3.c2;
    23592390 c3 = ec1.c3;
    2360 end ExpandableConnectors.NestedExpandable9;
     2391end ExpandableConnectors.Nested.NestedExpandable9;
    23612392")})));
    23622393    end NestedExpandable9;
     
    23682399       
    23692400        connector C = Real;
    2370    
     2401
    23712402        EC ec1, ec2, ec3, ec4, ec5;
    23722403        C c1, c2, c3;
     
    23852416            description="",
    23862417            flatModel="
    2387 fclass ExpandableConnectors.NestedExpandable10
     2418fclass ExpandableConnectors.Nested.NestedExpandable10
    23882419 Real ec1.c3;
    23892420 Real ec1.ec.c1;
     
    24162447 ec3.c2 = ec4.c2;
    24172448 ec4.c2 = ec5.ec.c2;
    2418 end ExpandableConnectors.NestedExpandable10;
     2449end ExpandableConnectors.Nested.NestedExpandable10;
    24192450")})));
    24202451    end NestedExpandable10;
     
    24252456            EC2[1] ec2;
    24262457        end EC1;
    2427        
     2458
    24282459        expandable connector EC2
    24292460        end EC2;
    2430        
    2431         connector C = Real;
    2432        
     2461
     2462        connector C = Real;
     2463
    24332464        EC1 ec1;
    24342465        model M
     
    24482479            description="Nested with for index on last part",
    24492480            flatModel="
    2450 fclass ExpandableConnectors.NestedExpandable11
     2481fclass ExpandableConnectors.Nested.NestedExpandable11
    24512482 Real ec1.ec2[1].a;
    24522483 Real c;
     
    24552486 c = ec1.ec2[1].a;
    24562487 ec1.ec2[1].a = m[1].ec2.a;
    2457 end ExpandableConnectors.NestedExpandable11;
     2488end ExpandableConnectors.Nested.NestedExpandable11;
    24582489")})));
    24592490    end NestedExpandable11;
    24602491
     2492
     2493package NestedError
     2494
    24612495    model NestedExpandableError1
    24622496        expandable connector EC
    24632497        end EC;
    2464        
     2498
    24652499        connector C1
    24662500            C2 c2;
    24672501        end C1;
    2468    
     2502
    24692503        connector C2 = Real;
    2470    
     2504
    24712505        EC ec;
    24722506        C1 c1;
     
    24922526        expandable connector EC
    24932527        end EC;
    2494        
     2528
    24952529        connector C1
    24962530            C2 c2;
    24972531        end C1;
    2498        
     2532
    24992533        connector C2
    25002534            C3 c3;
    25012535        end C2;
    2502    
     2536
    25032537        connector C3 = Real;
    2504    
     2538
    25052539        EC ec;
    25062540        C1 c1;
     
    25222556    end NestedExpandableError2;
    25232557
    2524 model ArrayIndexationType1
    2525     type E = enumeration(a,b,c);
    2526 
    2527     expandable connector EC
    2528         Real x[3];
    2529         Real y[Boolean];
    2530         Real z[E];
    2531     end EC;
    2532        
    2533     connector A = Real;
    2534    
    2535     EC ec;
    2536     A a[3];
    2537 equation
    2538     connect(a[1], ec.x[1]);
    2539     connect(a[2], ec.y[true]);
    2540     connect(a[3], ec.z[E.a]);
    2541 
    2542     annotation(__JModelica(UnitTesting(tests={
    2543         FlatteningTestCase(
    2544             name="ArrayIndexationType1",
    2545             description="Indexing with enums and bools in expandable connector, declared.",
    2546             flatModel="
    2547 fclass ExpandableConnectors.ArrayIndexationType1
    2548  Real ec.x[3];
    2549  Real ec.y[2];
    2550  Real ec.z[3];
    2551  Real a[3];
    2552 equation
    2553  a[1] = ec.x[1];
    2554  a[2] = ec.y[2];
    2555  a[3] = ec.z[1];
    2556  ec.x[2] = 0.0;
    2557  ec.x[3] = 0.0;
    2558  ec.y[1] = 0.0;
    2559  ec.z[2] = 0.0;
    2560  ec.z[3] = 0.0;
    2561 
    2562 public
    2563  type ExpandableConnectors.ArrayIndexationType1.E = enumeration(a, b, c);
    2564 
    2565 end ExpandableConnectors.ArrayIndexationType1;
    2566 ")})));
    2567 end ArrayIndexationType1;
    2568 
    2569 model ArrayIndexationType2
    2570     type E = enumeration(a,b,c);
    2571 
    2572     expandable connector EC
    2573         Real x[3];
    2574         Real y[Boolean];
    2575         Real z[E];
    2576     end EC;
    2577        
    2578     connector A = Real;
    2579    
    2580     EC ec;
    2581     A a[6];
    2582 equation
    2583     connect(a[1], ec.x[E.a]);
    2584     connect(a[2], ec.x[true]);
    2585     connect(a[3], ec.y[E.a]);
    2586     connect(a[4], ec.y[1]);
    2587     connect(a[5], ec.z[1]);
    2588     connect(a[6], ec.z[true]);
    2589 
    2590     annotation(__JModelica(UnitTesting(tests={
    2591         ErrorTestCase(
    2592             name="ArrayIndexationType2",
    2593             description="Indexing with enums and bools in expandable connector, declared.",
    2594             errorMessage="
    2595 6 errors found:
    2596 
    2597 Error at line 15, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo':
    2598   Expected array index of type 'Integer' found 'ExpandableConnectors.ArrayIndexationType2.E'
    2599 
    2600 Error at line 16, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo':
    2601   Expected array index of type 'Integer' found 'Boolean'
    2602 
    2603 Error at line 17, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo':
    2604   Expected array index of type 'Boolean' found 'ExpandableConnectors.ArrayIndexationType2.E'
    2605 
    2606 Error at line 18, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo':
    2607   Expected array index of type 'Boolean' found 'Integer'
    2608 
    2609 Error at line 19, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo':
    2610   Expected array index of type 'ExpandableConnectors.ArrayIndexationType2.E' found 'Integer'
    2611 
    2612 Error at line 20, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo':
    2613   Expected array index of type 'ExpandableConnectors.ArrayIndexationType2.E' found 'Boolean'
    2614 ")})));
    2615 end ArrayIndexationType2;
    2616 
    2617 model ArrayIndexationType3
    2618     type E = enumeration(a,b,c);
    2619 
    2620     expandable connector EC
    2621     end EC;
    2622        
    2623     connector A = Real;
    2624    
    2625     EC ec;
    2626     A a[6];
    2627 equation
    2628     connect(a[1], ec.x[1]);
    2629     connect(a[2], ec.y[true]);
    2630     connect(a[3], ec.z[E.a]);
    2631     connect(a[4], ec.x[3]);
    2632     connect(a[5], ec.y[false]);
    2633     connect(a[6], ec.z[E.b]);
    2634 
    2635     annotation(__JModelica(UnitTesting(tests={
    2636         FlatteningTestCase(
    2637             name="ArrayIndexationType3",
    2638             description="Indexing with enums and bools in expandable connector, undeclared.",
    2639             flatModel="
    2640 fclass ExpandableConnectors.ArrayIndexationType3
    2641  Real ec.x[3];
    2642  Real ec.y[2];
    2643  Real ec.z[2];
    2644  Real a[6];
    2645 equation
    2646  a[1] = ec.x[1];
    2647  a[2] = ec.y[2];
    2648  a[3] = ec.z[1];
    2649  a[4] = ec.x[3];
    2650  a[5] = ec.y[1];
    2651  a[6] = ec.z[2];
    2652  ec.x[2] = 0.0;
    2653 
    2654 public
    2655  type ExpandableConnectors.ArrayIndexationType3.E = enumeration(a, b, c);
    2656 
    2657 end ExpandableConnectors.ArrayIndexationType3;
    2658 ")})));
    2659 end ArrayIndexationType3;
    2660 
    2661 model ArrayIndexationType4
    2662     type E = enumeration(a,b,c);
    2663 
    2664     expandable connector EC
    2665     end EC;
    2666        
    2667     connector A = Real;
    2668    
    2669     EC ec;
    2670     A a[6];
    2671 equation
    2672     connect(a[1], ec.x[E.a]);
    2673     connect(a[2], ec.x[true]);
    2674     connect(a[3], ec.y[E.a]);
    2675     connect(a[4], ec.y[1]);
    2676     connect(a[5], ec.z[1]);
    2677     connect(a[6], ec.z[true]);
    2678 
    2679     annotation(__JModelica(UnitTesting(tests={
    2680         ErrorTestCase(
    2681             name="ArrayIndexationType4",
    2682             description="Indexing with enums and bools in expandable connector, undeclared.",
    2683             errorMessage="
    2684 3 errors found:
    2685 
    2686 Error at line 13, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo':
    2687   Array index type of component introduced to external connector does not match other connections to same name in connection set
    2688 
    2689 Error at line 15, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo':
    2690   Array index type of component introduced to external connector does not match other connections to same name in connection set
    2691 
    2692 Error at line 17, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo':
    2693   Array index type of component introduced to external connector does not match other connections to same name in connection set
    2694 ")})));
    2695 end ArrayIndexationType4;
     2558end NestedError;
     2559
     2560end Nested;
     2561
    26962562
    26972563
     
    26992565    expandable connector EC
    27002566    end EC;
    2701    
     2567
    27022568    connector C = Real;
    2703    
     2569
    27042570    model A
    27052571        extends D;
     
    27092575        connect(b.c, ec.c);
    27102576    end A;
    2711    
     2577
    27122578    model B
    27132579        C c = time;
    27142580    end B;
    2715    
     2581
    27162582    model D
    27172583        EC ec;
    27182584    end D;
    2719    
     2585
    27202586    A a;
    27212587
     
    27382604    expandable connector EC
    27392605    end EC;
    2740    
     2606
    27412607    connector C = Real;
    2742    
     2608
    27432609    model A
    27442610        extends D;
     
    27482614        connect(b.c, ec.c);
    27492615    end A;
    2750    
     2616
    27512617    model B
    27522618        C c = time;
    27532619    end B;
    2754    
     2620
    27552621    model D
    27562622        EC ec;
     
    27592625        connect(b2.c, ec.c2);
    27602626    end D;
    2761    
     2627
    27622628     A a;
    27632629
     
    27792645end DuplicatedExpandable2;
    27802646
     2647
     2648model AddToNestedAndConnectTopLevel
     2649    expandable connector EC
     2650    end EC;
     2651   
     2652    expandable connector EC2
     2653        EC ec;
     2654    end EC2;
     2655   
     2656    connector C = Real;
     2657   
     2658    EC ec1;
     2659    EC2 ec2;
     2660    C c;
     2661equation
     2662    connect(ec1, ec2);
     2663    connect(ec2.ec.c, c);
     2664
     2665annotation(__JModelica(UnitTesting(tests={
     2666    FlatteningTestCase(
     2667        name="AddToNestedAndConnectTopLevel",
     2668        description="Make sure that nested connectors that are only declared to work correctly.",
     2669        flatModel="
     2670fclass ExpandableConnectors.AddToNestedAndConnectTopLevel
     2671 Real ec1.ec.c;
     2672 Real ec2.ec.c;
     2673 Real c;
     2674equation
     2675 c = ec1.ec.c;
     2676 ec1.ec.c = ec2.ec.c;
     2677end ExpandableConnectors.AddToNestedAndConnectTopLevel;
     2678")})));
     2679end AddToNestedAndConnectTopLevel;
     2680
     2681
     2682package ConnectorArrays
    27812683
    27822684model ConnectorArray1
     
    28002702            description="Connecting to array of connectors",
    28012703            flatModel="
    2802 fclass ExpandableConnectors.ConnectorArray1
     2704fclass ExpandableConnectors.ConnectorArrays.ConnectorArray1
    28032705 input Real c[1].a[1];
    28042706 input Real c[1].b;
     
    28132715 ec.x.a[1:1] = zeros(1);
    28142716 ec.x.b = 0.0;
    2815 end ExpandableConnectors.ConnectorArray1;
     2717end ExpandableConnectors.ConnectorArrays.ConnectorArray1;
    28162718")})));
    28172719end ConnectorArray1;
     
    28382740            description="Connecting to array of connectors",
    28392741            flatModel="
    2840 fclass ExpandableConnectors.ConnectorArray2
     2742fclass ExpandableConnectors.ConnectorArrays.ConnectorArray2
    28412743 input Real c[1].a[1];
    28422744 input Real c[1].b;
     
    28622764 ec.x[2].a[1:1] = zeros(1);
    28632765 ec.x[2].b = 0.0;
    2864 end ExpandableConnectors.ConnectorArray2;
     2766end ExpandableConnectors.ConnectorArrays.ConnectorArray2;
    28652767")})));
    28662768end ConnectorArray2;
     
    28872789            description="Connecting to array of connectors",
    28882790            flatModel="
    2889 fclass ExpandableConnectors.ConnectorArray3
     2791fclass ExpandableConnectors.ConnectorArrays.ConnectorArray3
    28902792 input Real c[1].a[1];
    28912793 input Real c[1].b;
     
    29142816 ec.x[2].a[1:1] = zeros(1);
    29152817 ec.x[2].b = 0.0;
    2916 end ExpandableConnectors.ConnectorArray3;
     2818end ExpandableConnectors.ConnectorArrays.ConnectorArray3;
    29172819")})));
    29182820end ConnectorArray3;
     
    29402842            description="Connecting to array of connectors",
    29412843            flatModel="
    2942 fclass ExpandableConnectors.ConnectorArray4
     2844fclass ExpandableConnectors.ConnectorArrays.ConnectorArray4
    29432845 input Real c1.a[1];
    29442846 input Real c1.b;
     
    29722874 ec.x[3].a[1:1] = zeros(1);
    29732875 ec.x[3].b = 0.0;
    2974 end ExpandableConnectors.ConnectorArray4;
     2876end ExpandableConnectors.ConnectorArrays.ConnectorArray4;
    29752877")})));
    29762878end ConnectorArray4;
     
    29972899            description="Structural parameters in connector",
    29982900            flatModel="
    2999 fclass ExpandableConnectors.ConnectorArray5
     2901fclass ExpandableConnectors.ConnectorArrays.ConnectorArray5
    30002902 structural parameter Integer c[1].n = 2 /* 2 */;
    30012903 input Real c[1].a[2];
     
    30172919 ec.x[1].a[1:2] = zeros(2);
    30182920 ec.x[2].a[1:3] = zeros(3);
    3019 end ExpandableConnectors.ConnectorArray5;
     2921end ExpandableConnectors.ConnectorArrays.ConnectorArray5;
    30202922")})));
    30212923end ConnectorArray5;
     
    30432945            description="Array of stream connectors, with gap",
    30442946            flatModel="
    3045 fclass ExpandableConnectors.ConnectorArray6
     2947fclass ExpandableConnectors.ConnectorArrays.ConnectorArray6
    30462948 input Real c1.a;
    30472949 Real c1.b;
     
    30742976 ec.x[2].a = 0.0;
    30752977 ec.x[3].a = 0.0;
    3076 end ExpandableConnectors.ConnectorArray6;
     2978end ExpandableConnectors.ConnectorArrays.ConnectorArray6;
    30772979")})));
    30782980end ConnectorArray6;
     
    31033005            description="Modicication on connected component referring to parameter outside of it",
    31043006            flatModel="
    3105 fclass ExpandableConnectors.ConnectorArray7
     3007fclass ExpandableConnectors.ConnectorArrays.ConnectorArray7
    31063008 parameter Real a.p = 1 /* 1 */;
    31073009 Real a.c.a(start = a.p);
     
    31133015 a.c.b = ec.c.b;
    31143016 ec.c.a = 0.0;
    3115 end ExpandableConnectors.ConnectorArray7;
     3017end ExpandableConnectors.ConnectorArrays.ConnectorArray7;
    31163018")})));
    31173019end ConnectorArray7;
     
    31203022    expandable connector EC
    31213023    end EC;
    3122    
     3024
    31233025    connector C = Real;
    3124    
     3026
    31253027    EC ec1;
    31263028    C c[2];
     
    31353037            description="Expandable connector with for index",
    31363038            flatModel="
    3137 fclass ExpandableConnectors.ConnectorArray8
     3039fclass ExpandableConnectors.ConnectorArrays.ConnectorArray8
    31383040 Real ec1.a[2];
    31393041 Real c[2];
     
    31413043 c[1] = ec1.a[1];
    31423044 c[2] = ec1.a[2];
    3143 end ExpandableConnectors.ConnectorArray8;
     3045end ExpandableConnectors.ConnectorArrays.ConnectorArray8;
    31443046")})));
    31453047end ConnectorArray8;
     
    31483050    expandable connector EC
    31493051    end EC;
    3150    
     3052
    31513053    connector C = Real;
    3152    
     3054
    31533055    EC ec1;
    31543056    C c[2];
     
    31633065            description="Expandable connector with for index",
    31643066            flatModel="
    3165 fclass ExpandableConnectors.ConnectorArray9
     3067fclass ExpandableConnectors.ConnectorArrays.ConnectorArray9
    31663068 Real ec1.a[2];
    31673069 Real c[2];
     
    31693071 c[1] = ec1.a[1];
    31703072 c[2] = ec1.a[2];
    3171 end ExpandableConnectors.ConnectorArray9;
     3073end ExpandableConnectors.ConnectorArrays.ConnectorArray9;
    31723074")})));
    31733075end ConnectorArray9;
    31743076
    31753077
    3176 model ExpandableWithInputOutput1
    3177     connector CI = input Real;
    3178     connector CO = output Real;
    3179     connector C = Real;
    3180 
    3181     expandable connector EC
    3182     end EC;
    3183    
    3184     EC ec;
    3185     CI ci1;
    3186     CO co1;
    3187     input C ci2;
    3188     output C co2;
    3189 equation
    3190     connect(ci1, ec.ci1);
    3191     connect(ci2, ec.ci2);
    3192     connect(co1, ec.co1);
    3193     connect(co2, ec.co2);
    3194 
    3195     annotation(__JModelica(UnitTesting(tests={
    3196         FlatteningTestCase(
    3197             name="ExpandableWithInputOutput1",
    3198             description="Created variables in expandable connectors shouldn't be considered top-level input/outputs",
    3199             flatModel="
    3200 fclass ExpandableConnectors.ExpandableWithInputOutput1
    3201  ExpandableConnectors.ExpandableWithInputOutput1.CI ec.ci1;
    3202  Real ec.ci2;
    3203  ExpandableConnectors.ExpandableWithInputOutput1.CO ec.co1;
    3204  Real ec.co2;
    3205  input ExpandableConnectors.ExpandableWithInputOutput1.CI ci1;
    3206  output ExpandableConnectors.ExpandableWithInputOutput1.CO co1;
    3207  input Real ci2;
    3208  output Real co2;
    3209 equation
    3210  ci1 = ec.ci1;
    3211  ci2 = ec.ci2;
    3212  co1 = ec.co1;
    3213  co2 = ec.co2;
    3214 
    3215 public
    3216  type ExpandableConnectors.ExpandableWithInputOutput1.CI = Real;
    3217  type ExpandableConnectors.ExpandableWithInputOutput1.CO = Real;
    3218 end ExpandableConnectors.ExpandableWithInputOutput1;
    3219 ")})));
    3220 end ExpandableWithInputOutput1;
    3221 
    3222 
    3223 model FlowInExpandable1
    3224     connector C
    3225         Real p;
    3226         flow Real f;
    3227     end C;
    3228    
    3229     expandable connector EC
    3230     end EC;
    3231    
    3232     model A
    3233         B b;
    3234         EC ec;
    3235     equation
    3236         connect(b.c, ec.c);
    3237     end A;
    3238    
    3239     model B
    3240         C c;
    3241     end B;
    3242    
    3243     A a;
    3244     B b;
    3245     EC ec;
    3246 equation
    3247     connect(a.ec, ec);
    3248     connect(b.c, ec.c);
    3249 
    3250 annotation(__JModelica(UnitTesting(tests={
    3251     FlatteningTestCase(
    3252         name="FlowInExpandable1",
    3253         description="Check that flow variables in expandable connectors get zero equations as needed",
    3254         flatModel="
    3255 fclass ExpandableConnectors.FlowInExpandable1
    3256  Real a.b.c.p;
    3257  Real a.b.c.f;
    3258  Real a.ec.c.p;
    3259  Real a.ec.c.f;
    3260  Real b.c.p;
    3261  Real b.c.f;
    3262  Real ec.c.p;
    3263  Real ec.c.f;
    3264 equation
    3265  a.b.c.f - a.ec.c.f = 0.0;
    3266  a.ec.c.f + b.c.f - ec.c.f = 0.0;
    3267  a.ec.c.p = b.c.p;
    3268  b.c.p = ec.c.p;
    3269  a.b.c.p = a.ec.c.p;
    3270  ec.c.f = 0.0;
    3271 end ExpandableConnectors.FlowInExpandable1;
    3272 ")})));
    3273 end FlowInExpandable1;
     3078end ConnectorArrays;
     3079
     3080
    32743081
    32753082end ExpandableConnectors;
  • branches/dev-mj-1626/Compiler/ModelicaMiddleEnd/test/modelica/HybridModelTests.mo

    r12934 r13095  
    609609")})));
    610610        end IndependentDownstream1;
    611        
    612        
     611
     612
    613613        model PreMergeInteraction
    614614            Boolean sample1 = sample(1, 0.4);
     
    620620            end when;
    621621            b = a + 2;
    622        
    623         annotation(__JModelica(UnitTesting(tests={
    624             FClassMethodTestCase(
    625                 name="EventPreMerge.IndependentDownstream1",
     622
     623        annotation(__JModelica(UnitTesting(tests={
     624            FClassMethodTestCase(
     625                name="EventPreMerge.PreMergeInteraction",
    626626                description="Ensures event and pre merge interacts well with pre merge",
    627627                methodName="printDAEBLT",
     
    643643")})));
    644644        end PreMergeInteraction;
    645        
     645
    646646        model DiscreteRealMerge
    647647            discrete Real x;
  • branches/dev-mj-1626/Compiler/build-base.xml

    r12981 r13095  
    3232    <property name="java_compiler" value="javac${java_version}"/>
    3333
    34     <fail unless="target" message="Property 'target' not set. Should point to build directory where this ant file will generate intermediate files and build outputs. For builds in eclipse we normally use ${workspace_loc}/JModelica/tools/eclipse/antbuild."/>
     34    <fail unless="target" message="Property 'target' not set. Should point to build directory where this ant file will generate intermediate files and build outputs. For builds in eclipse we normally use ${workspace_loc:&lt;project&gt;/tools/eclipse/antbuild}."/>
    3535    <echo>build-base.xml: running in ${target}</echo>
    3636
     
    7676        <classpath path="${ant-contrib_dir}/target/ant-contrib.jar" />
    7777    </taskdef>
    78     <!-- "jastadd" is an ant task class in jastadd2.jar -->
    79     <taskdef classname="org.jastadd.JastAddTask" name="jastadd" classpath="${jastadd_dir}/jastadd2.jar" />
    8078    <!-- "jflex" is an ant task class for the scanner generator in JFlex.jar -->
    8179    <taskdef name="jflex" classname="JFlex.anttask.JFlexTask" classpath="${jflex_dir}/lib/JFlex.jar" />
     
    612610            <isset property="javadoc.packages"/>
    613611            <then>
    614                 <mkdir dir="${javadoc_output}" />
     612                <!-- The javadoc directory is sometimes unusable, unclear why.
     613                     It is recreated by the javadoc task. -->
     614                <delete dir="${javadoc_output}" />
    615615                <javadoc
    616616                    access="public"
  • branches/dev-mj-1626/RuntimeLibrary/src

  • branches/dev-mj-1626/RuntimeLibrary/src/jmi/jmi_block_log.c

    r10867 r13095  
    121121            }
    122122            if(log_level >= 3) {
    123                 jmi_log_reals(log, outer, logWarning, is_iter_var_flag?"ivs":"inputs", inputs, n);
     123                jmi_log_reals(log, outer, logWarning, is_iter_var_flag?"illegal_ivs":"inputs", inputs, n);
    124124
    125125            }
     
    197197            }
    198198            if(log_level >= 3) {
    199                 jmi_log_reals(log, outer, logWarning, is_iter_var_flag?"ivs":"inputs", inputs, n_inputs);
    200                 jmi_log_reals(log, outer, logWarning,  is_iter_var_flag?"residuals":"outputs", outputs, n_outputs);
     199                jmi_log_reals(log, outer, logWarning, is_iter_var_flag?"illegal_ivs":"inputs", inputs, n_inputs);
     200                jmi_log_reals(log, outer, logWarning,  is_iter_var_flag?"illegal_residuals":"outputs", outputs, n_outputs);
    201201
    202202            }
Note: See TracChangeset for help on using the changeset viewer.